Apuntes OpenMP

#pragma omp directive-name [clause, ...] newline

#pragma omp parallel default(shared) private(beta,pi)

Directivas:
parallel.- Una región parallel es un bloque de código que será ejecutado por multiples threads.
pasada la región parallel sólo continua el hilo principal en ejecución. Si algún thread
finaliza dentro de una región parallel todos los threads finalizan y su resultado no está
definido.
Work-Sharing Constructs:
DO / for Directive.- Las iteraciones del bucle serán ejecutadas en paralelo por todos los threads.
Se asume que está dentro de una región parallel. Mirar clausulas.
Sections.- Cada sección es ejecutada una vez por un thread del total (de threads). Diferentes
secciones pueden ser ejecutadas por diferentes threads.
single.- El código sólo es ejecutado por un thread del total.
barrier.- Sincroniza todos los threads en ejecución. Cuando un thread alcanza esta directiva espera hasta que
todos los demás threads lleguen a este punto y a continuación todos los threads se continuan ejecutando
en paralelo.


Opciones de compilación.
-xopenmp.- Equivalent to -xopenmp=parallel
-xopenmp=parallel.- Enables recognition of OpenMP pragmas Requires at least optimization level -xO3
-xopenmp=noopt.- Enables recognition of OpenMP pragmas The program is parallelized accordingly, but no
optimization is done *
-xopenmp=none.- Disables recognition of OpenMP pragmas (default)
-xloopinfo.- Display parallelization messages on screen
-stackvar.- Allocate local data on the stack (Fortran only) Use this when calling functions in parallel
Included with -xopenmp=parallel | noopt
-vpara/-xvpara.- Reports OpenMP scoping errors in case of incorrect parallelization (Fortran and C compiler only)
Also reports OpenMP scoping errors and race conditions statically detected by the compiler
-XlistMP.- Reports warnings about possible errors in OpenMP parallelization (Fortran only)
-xcommonchk.- option to report upon inconsistentusage of threadprivate

Video qlearnphrases

Video sobre como usar qlearnphrases.



Todavía sigo luchando con el algoritmo para crear textos decentes. En concreto estoy intentando que a partir de un título, se cree un texto relacionado con el texto. Estoy publicando los resultados en este otro blog: La biblia es verso.

qlearnphrases

A raiz de un articulo publicado en en divertimentosinformaticos he desarrollado una pequeña aplicación llamada qlearnphrases.

El fin de esta aplicación es aprender palabras y formar frases con más o menos sentido de las palabras aprendidas. Admite dos métodos para aprender palabras; desde fichero de texto y desde una caja de texto.

Además permite guardar las palabras aprendidas a fichero, aunque el almacenamiento no es muy optimo. Y saca un listado con todas las palabras aprendidas ordenadas por orden alfabético y con enlaces a las posibles palabras que le sucederán en las frases generadas.

He subido a google code el código del proyecto, para obtenerlo basta con escribir desde consola;

git clone https://code.google.com/p/qlearnphrases/

He usado git, porque nunca había trabajado con este gestor de código y siempre viene bien aprender algo nuevo.

Por lo demás sólo decir que el código no es muy decente, no libero ningún tipo de memoria, pero sólo es la primera versión, esper poder ir mejorando el programa poco a poco.

Como ejemplo la siguiente es una frase generada automáticamente por el programa:

Ser maestro implica gran prestigio y lo siguiente:
Que si dentro de los misales y Usuarios OCU asciende a la zona de ahorros.
Y como futuros docentes a la posterior se trata de nosotros.

No es muy coherente pero tengo que mejorar muchas cosas antes de ponerme a perfeccionar el algoritmo para generar frases.

Enjoy developing :)

Deselecionar filas en un QTableWidget.

He estado intentando eliminar la selección de una tabla QTableWidget, y la verdad es que me he demorado más de lo común debido a la forma en que se hace con qt.

La forma que me ha resultado más sencilla es la siguiente:

- Obtenemos el rango seleccionado mediante la función selectedRanges() del QTableWidget.
- Vamos recorriendo el rango y llamando a la función setRangeSelected() pasandole cada uno de los elementos QTableWidgetSelectionRange y el parámetro false para quitar la selección.

Aquí dejo el código de ejemplo, está hecho en java con qtjambi

      List unselectRange = ui.tableWidgetUsers.selectedRanges();
      for(QTableWidgetSelectionRange range : unselectRange)
      {
        ui.tableWidgetUsers.setRangeSelected(range, false);
      }

Aplicando parches con diff.

En los proyectos de software libre es común que los programadores envíen sus parches de código fuente a un proyecto dado. La forma de aplicar los parches es con el comando patch.

Supongamos que tenemos el siguiente código fuente:
fib1.c

#include 
#include 

/* Find the nth Fibonacci number. */
static int fib(int n)
{
  if (n <= 0)
    return 0;
  if (n == 1)
    return 1;
  return fib(n - 1) + fib(n - 2);
}

int main(int argc, char** argv)
{
  if (argc < 2) {
    fprintf(stderr, "Need an argument.\n");
    return 1;
  }

  printf("%d\n", fib(atoi(argv[1])));
  return 0;
}

Y hemos recibido el siguiente parche: fib-linear-time.patch

--- fib1.c 
+++ fib2.c 
@@ -4,11 +4,17 @@
 /* Find the nth Fibonacci number. */
 static int fib(int n)
 {
-  if (n <= 0)
-    return 0;
-  if (n == 1)
-    return 1;
-  return fib(n - 1) + fib(n - 2);
+  int prev = 1;
+  int current = 0;
+  int i;
+
+  for (i = 0; i < n; i++) {
+    int next = current + prev;
+    prev = current;
+    current = next;
+  }
+
+  return current;
 }
 
 int main(int argc, char** argv)

Para aplicar el parche simplemente debemos ejecutar la siguiente orden desde consola:

patch < fib-linear-time.patch

Y con esto nuestro archivo fib1.c quedaría de la forma siguiente: fib1.c

#include 
#include 

/* Find the nth Fibonacci number. */
static int fib(int n)
{
  int prev = 1;
  int current = 0;
  int i;

  for (i = 0; i < n; i++) {
    int next = current + prev;
    prev = current;
    current = next;
  }

  return current;
}

int main(int argc, char** argv)
{
  if (argc < 2) {
    fprintf(stderr, "Need an argument.\n");
    return 1;
  }

  printf("%d\n", fib(atoi(argv[1])));
  return 0;
}

QString to const char*. Convetir QString a const char*

Cuando empezamos a programar en qt es común que no sepamos convertir converir un QString en char*.
Una forma rápida y sencilla de convertir un QString en un const char* es la siguiente.

String str("hello");
const char* ch = str.toLocal8Bit().constData();

Usar qDebug con QString

Últimamente he estado teniendo problemas al usar la función qDebug y pasarle un QString como parámetro.

"no matching function for call to 'qDegug(Qstring&)"

El problema, como podemos ver, es que no hay ninguna función qDebug que acepte un QString como parámetro.

La solución es usar el operador << para indicarle que QString queremos imprimir. Sería algo así:

QString text("hello qt");
qDegug() << text;

Añadir elementos a una QToolBar

Para añadir elementos desde el diseñador a una QToolBar hace falta en primer lugar crear QActions, estos se pueden crear fácilmente desde la vista de diseñar widgets, una vez creados, hay que pinchar sobre el QAction en cuestión que queremos añadir y arrastrarlo hacia la QToolBar.

Además si queremos que los QActions luzcan con icono, debemos crearnos un fichero de recursos qrc, allí iremos importando los iconos necesarios y posteriormente se los asignamos a los QActions.

Acabo de crear los botones de la barra de herramientas de la aplicación y de asignarle sus iconos correspondientes. He obtenido los iconos de freeiconsdownload ya que tienen una licencia que permite usarlos en proyectos no comercial.

Dejo una captura de pantalla del estado actual de la aplicación. En principio está desarrollada como MDI.

El código de esta versión se puede descargar desde aquí:

svn checkout http://infobasic.googlecode.com/svn/tags/infobasic-0.0.4 infobasic-read-only

Servidor simple de echo UDP

Ya tengo listo el servidor UDP de echo, la verdad es que las herramientas que nos brindan las librerías Qt son muy potentes y fáciles de usar.

echoserver.h

#ifndef ECHOSERVER_H
#define ECHOSERVER_H

#include "IForm.h"
#include 
#include 

namespace Ui {
    class EchoServer;
}

class EchoServer : public QWidget
{
    Q_OBJECT

public:
    explicit EchoServer(QWidget *parent = 0);
    virtual ~EchoServer();
    static const quint16 PORT_MIN;
    static const quint16 PORT_MAX;
    static const quint16 PORT_DEFAULT;

protected:
    QUdpSocket *udpServer;

    virtual void putTexts();
    virtual void setuid();

    static const QString START;
    static const QString STOP;

public slots:
    void onClickStart();
    void readPendingDatagrams();

private:
    Ui::EchoServer *ui;
    bool started;

};

#endif // ECHOSERVER_H

echoserver.cpp

#include "echoserver.h"
#include "ui_echoserver.h"
#include 

const quint16 EchoServer::PORT_MIN = 1;
const quint16 EchoServer::PORT_MAX = 65535;
const quint16 EchoServer::PORT_DEFAULT = 8888;

const QString EchoServer::START = tr("Start");
const QString EchoServer::STOP = tr("Stop");

EchoServer::EchoServer(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::EchoServer)
{
    ui->setupUi(this);
    this->udpServer = new QUdpSocket(this);
    this->started = false;
    putTexts();
    setuid();    
}

EchoServer::~EchoServer()
{
    delete ui;
    delete this->udpServer;
    qDebug("Delete EchoServer");
}

void EchoServer::putTexts()
{
    this->setWindowTitle(tr("Servidor echo UDP"));
    ui->lbPort->setText(tr("Port"));
    ui->pbStart->setText(tr("Start"));
}

void EchoServer::setuid()
{
    setAttribute(Qt::WA_DeleteOnClose);
    connect(ui->pbStart, SIGNAL(clicked()),SLOT(onClickStart()));
    connect(ui->sldPort, SIGNAL(valueChanged(int)), ui->lcdPort, SLOT(display(int)));

    ui->sldPort->setMinimum(EchoServer::PORT_MIN);
    ui->sldPort->setMaximum(EchoServer::PORT_MAX);
    ui->sldPort->setValue(EchoServer::PORT_DEFAULT);
}

void EchoServer::onClickStart()
{

    if(!this->started)
    {
        qDebug("Server started");
        quint16 port = ui->lcdPort->value();
        udpServer->bind(port, QUdpSocket::ShareAddress);
        connect(udpServer, SIGNAL(readyRead()), this, SLOT(readPendingDatagrams()));
        ui->pbStart->setText(STOP);
    } else
    {
        qDebug("Server stoped");
        udpServer->close();
        ui->pbStart->setText(START);
    }

    this->started = !this->started;
}

void EchoServer::readPendingDatagrams()
{
    qDebug("readPendingDatagrams");
    while (udpServer->hasPendingDatagrams())
    {
         QByteArray datagram;
         datagram.resize(udpServer->pendingDatagramSize());
         QHostAddress sender;
         quint16 senderPort;

         udpServer->readDatagram(datagram.data(), datagram.size(),
                                 &sender, &senderPort);

         QString str(datagram);
         str.append(" from " + sender.toString() + " on " + QDateTime::currentDateTime().toString()+ "\n");
         ui->textBrowser->insertPlainText(str);
         udpServer->writeDatagram(datagram, sender, senderPort);
     }
}

Para iniciar el servidor, simplemente hay que indicar el puerto por el que escuchará y el modo. Además hay que conectar la llegada de paquetes a una función, en este caso la función es readPendingDatagrams() y se ejecutará cada vez que llegue un paquete UDP.

quint16 port = ui->lcdPort->value();
udpServer->bind(port, QUdpSocket::ShareAddress);
connect(udpServer, SIGNAL(readyRead()), this, SLOT(readPendingDatagrams()));

En la función readPendingDatagrams() es donde se realiza el procesamiento de datos y se monta la respuesta para el cliente. En este caso el procesamiento de datos consiste en sacar los datos recibidos por pantalla y la respuesta contiene exactamente los mismos datos que se han recibido.

while (udpServer->hasPendingDatagrams())
{
     QByteArray datagram;
     datagram.resize(udpServer->pendingDatagramSize());
     QHostAddress sender;
     quint16 senderPort;

     udpServer->readDatagram(datagram.data(), datagram.size(),&sender, &senderPort);

     QString str(datagram);
     str.append(" from " + sender.toString() + " on " + QDateTime::currentDateTime().toString()+ "\n");
     ui->textBrowser->insertPlainText(str);
     udpServer->writeDatagram(datagram, sender, senderPort);
}

Como siempre podeis descargar el código desde el svn, para esta versión en concreto desde aquí:

svn checkout http://infobasic.googlecode.com/svn/tags/infobasic-0.0.3 infobasic-read-only

QByteArray to QString

Para convertir un objeto QByteArray a QString simplemente hay que pasarle el QByteArray al QString en el constructor. Ejemplo:

QByteArray datagram;

... //Suponemos que el QByteArray tiene datos. 

QString str(datagram);

Cliente simple echo. UDP. Añadida selección de puerto.

Se ha añadido al cliente echo udp, la selección de puerto, para ello se ha usado un QSlider y un QLCDNumber.

Conectamos el valor producido por el QSlider al valor mostrado en el QLCDNumber y configuramos los valore máximos y mínimos del QSlider a los valores de puerto máximo y mínimo respectivamente.

const quint16 EchoClient::PORT_MIN = 1;
const quint16 EchoClient::PORT_MAX = 65535;
const quint16 EchoClient::PORT_DEFAULT = 8888;

...

void EchoClient::setuid()
{
    setAttribute(Qt::WA_DeleteOnClose);
    connect(ui->pbSend, SIGNAL(clicked()),SLOT(onClickSend()));
    connect(ui->sldPort, SIGNAL(valueChanged(int)), ui->lcdPort, SLOT(display(int)));

    ui->sldPort->setMinimum(EchoClient::PORT_MIN);
    ui->sldPort->setMaximum(EchoClient::PORT_MAX);
    ui->sldPort->setValue(EchoClient::PORT_DEFAULT);
}

Por último en la función de enviar cogemos el valor del puerto del QLCDNumber y lo enviamos al host especificado en el QLineEdit.

void EchoClient::onClickSend()
{
    qDebug("onClickSend");

    QHostInfo info = QHostInfo::fromName(ui->leServerName->text());
    if (!info.addresses().isEmpty())
    {
        QHostAddress address = info.addresses().first();
        QByteArray ba = ui->leText->text().toLocal8Bit();
        const char *txt = ba.data();
        qint16 len = ui->leText->text().length();
        qint16 port = ui->sldPort->value();

        QUdpSocket *udp =new QUdpSocket(this);
        udp->writeDatagram(txt, len, address,  port);
        delete udp;
    } else
    {
        QMessageBox msgBox;
        msgBox.setWindowTitle(tr("Error"));
        msgBox.setText(tr("Error host not found"));
        msgBox.setIcon(QMessageBox::Critical);
        msgBox.setStandardButtons(QMessageBox::Ok);
        msgBox.exec();
    }
}

Para descargar esta versión:
svn checkout http://infobasic.googlecode.com/svn/tags/infobasic-0.0.2 infobasic-read-only

Nuevas tareas en google code.

Voy a ir definiendo las próximas acciones de desarrollo en google code. No se muy bien en que va a acabar la aplicación pero la idea es que poco a poco se vayan definiendo nuevas tareas y objetivos para seguir practicando con las herramientas que nos proveen las librerias qt. Las nuevas tareas se irán definiendo en la siguiente página. http://code.google.com/p/infobasic/issues/list

Analisis de datos enviados por el cliente udp.

Al capturar los datos enviado por nuestro cliente de echo UDP obteniamos la siguiente secuencia de bytes:

0x0000:  4500 0028 0000 4000 4011 3cc3 7f00 0001  E..(..@.@.<.....
0x0010:  7f00 0001 df38 22b8 0014 fe27 6865 6c6c  .....8"....'hell
0x0020:  6f20 7365 7276 6572                      o.server

Teniendo en cuenta que el encabezado de un paquete UDP es el siguiente:

puerto de origen (16 bits)	puerto de destino (16 bits)
longitud total (16 bits)	suma de comprobación del encabezado (16 bits)
datos (longitud variable).

Tenemos que:

Puerto origen: df38 (2 bytes)
Puerto destino: 22b8 (2 bytes. 0x22b8 es 8888 en decimal)
Longitud total: 0014 (2 bytes. La longitud total es de 20 bytes, es decir 0x14 en hexadecimal)
Checksum: fe27 (2 bytes)
Datos enviados: 6865 6c6c 6f20 7365 7276 6572 (12 bytes)

Los datos anteriores corresponde al protocolo IP en el que va montada la trama UDP.

0x0000:  4500 0028 0000 4000 4011 3cc3 7f00 0001  E..(..@.@.<.....
0x0010:  7f00 0001

Y su significado es el siguiente:

Versión: 45 (4 bits 1/2 byte, 0100 significa que se está usando la versión IPV4)
Longitud del encabezado: 00 (4 bits, 1/2 byte, 0101 es decir 5 en decimal)
Tipo de servicio: 00 (1 bytes)
Longitud total: 0028 (2 bytes, corresponde a una longitude de 40 bytes)
Identificación: 0000 (2 bytes)
Fragment offset: 4000 (2 bytes)
Tiempo de vida: 40 (1 byte)
Protocolo: 11 (1 byte, corresponde al protocolo UDP 17 en decimal)
Checksum de la cabecera: 3cc3 (2 bytes)
Dirección origen: 7f00 0001 (4 bytes, 127.0.0.1)
Dirección destino: 7f00 0001 (4 bytes, 127.0.0.1)

El formato de un paquete IP es el siguiente:

Versión (4 bits)	Longitud del encabezado (4 bits)	Tipo de servicio (8 bits)	Longitud total (16 bits)
Identificación (16 bits)			Indicador (3 bits)	Margen del fragmento (13 bits)
Tiempo de vida (8 bits)		Protocolo (8 bits)	Suma de comprobación del encabezado (16 bits)
Dirección IP de origen (32 bits)
Dirección IP de destino (32 bits)
Datos

En los posteriores post intentaré analizar cuales son las diferencias al utilizar diferentes protocolos como TCP y diferentes puertos para el cliente de echo.

Infobasic svn

Acabo de subir el código del programa ejemplo infobasic al un repositorio en google code. La dirección para descargar la rama principal es la siguiente:

svn checkout http://infobasic.googlecode.com/svn/trunk/ infobasic-read-only

Para descargar la versión que tiene como último elemento añadido la el diálogo de about:

svn checkout http://infobasic.googlecode.com/svn/tags/infobasic-0.0.1 infobasic-read-only

Convertir un label en un hipervinculo.

Hay raiz de una consulta en el foro de zonaqt he ampliado mi programa InfoBasic para ponerle un dialogo con un enlace a la esta misma web. Aquí dejo el código:

aboutdialog.h

#ifndef ABOUTDIALOG_H
#define ABOUTDIALOG_H

#include "IForm.h"
#include 

namespace Ui {
    class AboutDialog;
}

class AboutDialog : public QDialog, public IForm
{
    Q_OBJECT

public:
    static const char* HREF;
    static const char* HREF2;
    explicit AboutDialog(QWidget *parent = 0);
    ~AboutDialog();

    virtual void putTexts();
    virtual void setuid();

public slots:
    void onClickLink();

private:
    Ui::AboutDialog *ui;
};

#endif // ABOUTDIALOG_H

aboutdialog.cpp

#include "aboutdialog.h"
#include "ui_aboutdialog.h"
#include 
#include 

const char* AboutDialog::HREF ="Orgía de objetos";
const char* AboutDialog::HREF2 ="Thank you for visiting us.";

AboutDialog::AboutDialog(QWidget *parent) :
    QDialog(parent),
    ui(new Ui::AboutDialog)
{
    ui->setupUi(this);
    putTexts();
    setuid();
}

AboutDialog::~AboutDialog()
{
    delete ui;
}

void AboutDialog::onClickLink()
{
    qDebug("onClickLink");
    QString str = ui->labelLink->text();
    int startIndex = str.indexOf(QString("'"));
    int endIndex = str.indexOf(QString("'"), ++startIndex);
    qDebug(str.mid(startIndex, endIndex).toLocal8Bit().data());
    QDesktopServices::openUrl(QUrl(str.mid(startIndex, endIndex - startIndex)));
    ui->labelLink->setText(HREF2);
}

void AboutDialog::putTexts()
{
    ui->labelLink->setText(HREF);
    ui->labelLink->adjustSize();
}

void AboutDialog::setuid()
{
    connect(ui->labelLink, SIGNAL(linkActivated(QString)), this, SLOT(onClickLink()));
}

Este código abre la dirección del QLabel en el explorador por defecto.

En los próximos días voy a intentar sacar tiempo para subir el código fuente.

Cliente simple echo. UDP.

Se trata de un cliente UDP de echo. Consta de un una caja de texto para escribir el nombre del servidor, y una otra caja de texto para enviar texto en claro al servidor. Aquí dejo la implementación de la clase principal.

echoclient.h

#ifndef ECHOCLIENT_H
#define ECHOCLIENT_H

#include < QWidget>
#include "IForm.h"

namespace Ui {
    class EchoClient;
}

class EchoClient : public QWidget, public IForm
{
    Q_OBJECT

public:
    explicit EchoClient(QWidget *parent = 0);
    virtual ~EchoClient();

    virtual void putTexts();
    virtual void setuid();

public slots:
    void onClickSend();

private:
    Ui::EchoClient *ui;
};

#endif // ECHOCLIENT_H

echoclient.cpp

#include "echoclient.h"
#include "ui_echoclient.h"
#include "qtudpclient.h"
#include < QUdpSocket>
#include < QHostAddress>
#include < iostream>

EchoClient::EchoClient(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::EchoClient)
{
    ui->setupUi(this);
    putTexts();
    setuid();
}

EchoClient::~EchoClient()
{
    delete ui;
    qDebug("Delete EchoClient");
}

void EchoClient::putTexts()
{
    ui->lbServerName->setText(tr("Server Name"));
    ui->lbText->setText(tr("Text"));
    ui->leServerName->setText("localhost");
    ui->pbSend->setText(tr("Send"));
}

void EchoClient::setuid()
{
    setAttribute(Qt::WA_DeleteOnClose);
    connect(ui->pbSend, SIGNAL(clicked()),SLOT(onClickSend()));
}

void EchoClient::onClickSend()
{
    qDebug("onClickSend");
    QUdpSocket *udp =new QUdpSocket(this);
    const QHostAddress *host = new QHostAddress(ui->leServerName->text());

    //const char *txt = (const char*) ui->leText->text().toLocal8Bit().data();
    QByteArray ba = ui->leText->text().toLocal8Bit();
    const char *txt = ba.data();
    qint16 len = ui->leText->text().length();
    qint16 port = 8888;
    udp->writeDatagram(txt, len, QHostAddress::LocalHost,  port);
    qDebug(ui->leServerName->text().toStdString().c_str());
    delete host;
    delete udp;
}

Y aquí podemos ver la información enviada al servidor:

sudo tcpdump -xX -i lo
0x0000:  4500 0028 0000 4000 4011 3cc3 7f00 0001  E..(..@.@.<.....
0x0010:  7f00 0001 c30e 22b8 0014 fe27 6865 6c6c  ......"....'hell
0x0020:  6f20 7365 7276 6572                      o.server

En los próximos envíos veremos la interpretación de esta información y apliaremos el cliente para que sea capaz de recibir e interpretar las respuestas del servidor.

Patrones de diseño.

Actualmente estoy leyendo un sobre patrones de diseño, es mi intención comentar e implementar los ejemplos propuestos. Aunque el libro está orientado a programación en java intentaré desarrollar todos los ejercicios usando c++ con las librerías qt y bajo una ubuntu 11.04.

Además pienso ir publicando mis pequeños programas que realizarán acciones básicas con las qt.

Hello blogger!

My first post from Blogilo!