Ars Longa, Vita Brevis » C/C++ http://blog.sjinks.pro Quod scripsi, scripsi Mon, 06 Feb 2012 17:56:02 +0000 en hourly 1 HTML Parser для Qt http://blog.sjinks.pro/c-cpp/qt/942-html-parser-qt/ http://blog.sjinks.pro/c-cpp/qt/942-html-parser-qt/#comments Wed, 07 Sep 2011 08:03:07 +0000 Vladimir http://blog.sjinks.pro/?p=942 © 2012 Ars Longa, Vita Brevis. Все права защищены. Перепубликация материалов без разрешения автора запрещена.

При использовании материалов блога наличие активной не закрытой от индексирования ссылки на источник обязательно.

]]> Использование libxml2 для разбора документов в

 — это, конечно, хорошо, но очень часто требуется разбирать документы HTML, которые могут и не быть валидными.

В Qt есть множество классов для работы с XML, но они не подходят для HTML, так как ошибки в HTML для них фатальны.

Ниже приведён вариант парсера для HTML, основанный на библиотеке libxml2.

#ifndef LIBXML2READER_H
#define LIBXML2READER_H

#include <QtXml/QXmlReader>
#include <libxml/xmlstring.h>

class LibXml2ReaderPrivate;

class LibXml2Reader : public QXmlReader {
public:
    LibXml2Reader(void);
    virtual ~LibXml2Reader(void);

    virtual bool feature(const QString& name, bool* ok = 0) const;
    virtual void setFeature(const QString& name, bool value);
    virtual bool hasFeature(const QString& name) const;
    virtual void* property(const QString& name, bool* ok = 0) const;
    virtual void setProperty(const QString& name, void* value);
    virtual bool hasProperty(const QString& name) const;

    virtual void setEntityResolver(QXmlEntityResolver* handler);
    virtual QXmlEntityResolver* entityResolver(void) const;
    virtual void setDTDHandler(QXmlDTDHandler* handler);
    virtual QXmlDTDHandler* DTDHandler(void) const;
    virtual void setContentHandler(QXmlContentHandler* handler);
    virtual QXmlContentHandler* contentHandler(void) const;
    virtual void setErrorHandler(QXmlErrorHandler* handler);
    virtual QXmlErrorHandler* errorHandler(void) const;
    virtual void setLexicalHandler(QXmlLexicalHandler* handler);
    virtual QXmlLexicalHandler* lexicalHandler(void) const;
    virtual void setDeclHandler(QXmlDeclHandler* handler);
    virtual QXmlDeclHandler* declHandler(void) const;

    virtual bool parse(const QXmlInputSource& input);
    virtual bool parse(const QXmlInputSource* input);


private:
    Q_DISABLE_COPY(LibXml2Reader)
    Q_DECLARE_PRIVATE(LibXml2Reader)
    QScopedPointer<LibXml2ReaderPrivate> d_ptr;

    friend class LibXml2ReaderLocator;
};

#endif // LIBXML2READER_H
#include "libxml2reader.h"
#include <cstring>
#include <libxml/tree.h>
#include <libxml/parser.h>
#include <libxml/HTMLparser.h>

class LibXml2ReaderLocator : public QXmlLocator {
public:
    LibXml2ReaderLocator(LibXml2Reader* r) : reader(r) {}
    virtual int columnNumber(void) const;
    virtual int lineNumber(void) const;
private:
    LibXml2Reader* reader;
};

class LibXml2ReaderPrivate {
public:
    ~LibXml2ReaderPrivate(void) {}
private:
    LibXml2ReaderPrivate(LibXml2Reader* reader);

    static void startDocument(void* c);
    static void endDocument(void* c);
    static void startElement(void* c, const xmlChar* name, const xmlChar** attrs);
    static void endElement(void* c, const xmlChar* name);
    static void comment(void* c, const xmlChar* value);
    static void cdataBlock(void* c, const xmlChar* value, int len);
    static void processingInstruction(void* c, const xmlChar* target, const xmlChar* data);
    static void characters(void* c, const xmlChar* ch, int len);
    static void ignorableWhitespace(void* c, const xmlChar* ch, int len);
    static void internalSubset(void* c, const xmlChar* name, const xmlChar* publicId, const xmlChar* systemId);

    void parse(const QXmlInputSource* input);

    QScopedPointer<LibXml2ReaderLocator> locator;
    Q_DECLARE_PUBLIC(LibXml2Reader)
    LibXml2Reader* q_ptr;

    QXmlEntityResolver* entityresolver;
    QXmlDTDHandler*     dtdhandler;
    QXmlContentHandler* contenthandler;
    QXmlErrorHandler*   errorhandler;
    QXmlLexicalHandler* lexicalhandler;
    QXmlDeclHandler*    declhandler;

    xmlParserCtxt* context;

    friend class LibXml2ReaderLocator;
};

LibXml2ReaderPrivate::LibXml2ReaderPrivate(LibXml2Reader* reader)
    : q_ptr(reader), entityresolver(0), dtdhandler(0), contenthandler(0), errorhandler(0), lexicalhandler(0), declhandler(0), context(0)
{
    this->locator.reset(new LibXml2ReaderLocator(reader));
}

void LibXml2ReaderPrivate::parse(const QXmlInputSource* input)
{
    htmlSAXHandler handler;
    QByteArray arr = input->data().toLocal8Bit();
    const char* data = arr.data();

    std::memset(&handler, 0, sizeof(handler));
    handler.startDocument         = &LibXml2ReaderPrivate::startDocument;
    handler.endDocument           = &LibXml2ReaderPrivate::endDocument;
    handler.startElement          = &LibXml2ReaderPrivate::startElement;
    handler.endElement            = &LibXml2ReaderPrivate::endElement;
    handler.comment               = &LibXml2ReaderPrivate::comment;
    handler.cdataBlock            = &LibXml2ReaderPrivate::cdataBlock;
    handler.processingInstruction = &LibXml2ReaderPrivate::processingInstruction;
    handler.characters            = &LibXml2ReaderPrivate::characters;
    handler.ignorableWhitespace   = &LibXml2ReaderPrivate::ignorableWhitespace;
    handler.internalSubset        = &LibXml2ReaderPrivate::internalSubset;

    this->context = htmlCreatePushParserCtxt(&handler, this, data, xmlStrlen(reinterpret_cast<const xmlChar*>(data)), "", XML_CHAR_ENCODING_NONE);
    htmlParseChunk(this->context, NULL, 0, 1);
    htmlFreeParserCtxt(this->context);
    xmlCleanupParser();
}

void LibXml2ReaderPrivate::startDocument(void* c)
{
    LibXml2ReaderPrivate* r = reinterpret_cast<LibXml2ReaderPrivate*>(c);
    if (r->contenthandler) {
        r->contenthandler->startDocument();
    }
}

void LibXml2ReaderPrivate::endDocument(void* c)
{
    LibXml2ReaderPrivate* r = reinterpret_cast<LibXml2ReaderPrivate*>(c);
    if (r->contenthandler) {
        r->contenthandler->endDocument();
    }
}

void LibXml2ReaderPrivate::startElement(void* c, const xmlChar* name, const xmlChar** attrs)
{
    LibXml2ReaderPrivate* r = reinterpret_cast<LibXml2ReaderPrivate*>(c);
    if (r->contenthandler) {
        QXmlAttributes a;

        int i = 0;
        if (attrs) {
            while (attrs[i]) {
                const char* name  = reinterpret_cast<const char*>(attrs[i]);
                const char* value = reinterpret_cast<const char*>(attrs[i+1]);
                i += 2;
                a.append(name, "", "", value ? value : name);
            }
        }

        QString uri = "";
        QString localName = "";
        QString qName = reinterpret_cast<const char*>(name);
        r->contenthandler->startElement(uri, localName, qName, a);
    }
}

void LibXml2ReaderPrivate::endElement(void* c, const xmlChar* name)
{
    LibXml2ReaderPrivate* r = reinterpret_cast<LibXml2ReaderPrivate*>(c);
    if (r->contenthandler) {
        r->contenthandler->endElement(QString(""), QString(""), QString(reinterpret_cast<const char*>(name)));
    }
}

void LibXml2ReaderPrivate::comment(void* c, const xmlChar* value)
{
    LibXml2ReaderPrivate* r = reinterpret_cast<LibXml2ReaderPrivate*>(c);
    if (r->lexicalhandler) {
        r->lexicalhandler->comment(QString::fromLocal8Bit(reinterpret_cast<const char*>(value)));
    }
}

void LibXml2ReaderPrivate::cdataBlock(void* c, const xmlChar* value, int len)
{
    LibXml2ReaderPrivate* r = reinterpret_cast<LibXml2ReaderPrivate*>(c);
    if (r->lexicalhandler) {
        r->lexicalhandler->startCDATA();
        if (r->contenthandler) {
            QByteArray arr(reinterpret_cast<const char*>(value), len);
            r->contenthandler->characters(arr);
        }

        r->lexicalhandler->endCDATA();
    }
}

void LibXml2ReaderPrivate::processingInstruction(void* c, const xmlChar* target, const xmlChar* data)
{
    LibXml2ReaderPrivate* r = reinterpret_cast<LibXml2ReaderPrivate*>(c);
    if (r->contenthandler) {
        r->contenthandler->processingInstruction(reinterpret_cast<const char*>(target), reinterpret_cast<const char*>(data));
    }
}

void LibXml2ReaderPrivate::characters(void* c, const xmlChar* ch, int len)
{
    LibXml2ReaderPrivate* r = reinterpret_cast<LibXml2ReaderPrivate*>(c);
    if (r->contenthandler) {
        r->contenthandler->characters(QString::fromLocal8Bit(reinterpret_cast<const char*>(ch), len));
    }
}

void LibXml2ReaderPrivate::ignorableWhitespace(void* c, const xmlChar* ch, int len)
{
    LibXml2ReaderPrivate* r = reinterpret_cast<LibXml2ReaderPrivate*>(c);
    if (r->contenthandler) {
        r->contenthandler->ignorableWhitespace(QString::fromLocal8Bit(reinterpret_cast<const char*>(ch), len));
    }
}

void LibXml2ReaderPrivate::internalSubset(void* c, const xmlChar* name, const xmlChar* publicId, const xmlChar* systemId)
{
    LibXml2ReaderPrivate* r = reinterpret_cast<LibXml2ReaderPrivate*>(c);
    if (r->lexicalhandler) {
        QString n(QString::fromLocal8Bit(reinterpret_cast<const char*>(name)));
        QString p(QString::fromLocal8Bit(reinterpret_cast<const char*>(publicId)));
        QString s(QString::fromLocal8Bit(reinterpret_cast<const char*>(systemId)));
        r->lexicalhandler->startDTD(n, p, s);
        r->lexicalhandler->endDTD();
    }

}

LibXml2Reader::LibXml2Reader(void)
    : d_ptr(new LibXml2ReaderPrivate(this))
{
}

LibXml2Reader::~LibXml2Reader(void)
{
}

bool LibXml2Reader::feature(const QString&, bool* ok) const
{
    if (ok) {
        *ok = false;
    }

    return false;
}

void LibXml2Reader::setFeature(const QString&, bool)
{
}

bool LibXml2Reader::hasFeature(const QString&) const
{
    return false;
}

void* LibXml2Reader::property(const QString&, bool* ok) const
{
    if (ok) {
        *ok = false;
    }

    return 0;
}

void LibXml2Reader::setProperty(const QString&, void*)
{
}

bool LibXml2Reader::hasProperty(const QString&) const
{
    return false;
}

void LibXml2Reader::setEntityResolver(QXmlEntityResolver* handler)
{
    Q_D(LibXml2Reader);
    d->entityresolver = handler;
}

QXmlEntityResolver* LibXml2Reader::entityResolver(void) const
{
    const LibXml2ReaderPrivate* d = this->d_func();
    return d->entityresolver;
}

void LibXml2Reader::setDTDHandler(QXmlDTDHandler* handler)
{
    Q_D(LibXml2Reader);
    d->dtdhandler = handler;
}

QXmlDTDHandler* LibXml2Reader::DTDHandler(void) const
{
    const LibXml2ReaderPrivate* d = this->d_func();
    return d->dtdhandler;
}

void LibXml2Reader::setContentHandler(QXmlContentHandler* handler)
{
    Q_D(LibXml2Reader);
    d->contenthandler = handler;
}

QXmlContentHandler* LibXml2Reader::contentHandler(void) const
{
    const LibXml2ReaderPrivate* d = this->d_func();
    return d->contenthandler;
}

void LibXml2Reader::setErrorHandler(QXmlErrorHandler* handler)
{
    Q_D(LibXml2Reader);
    d->errorhandler = handler;
}

QXmlErrorHandler* LibXml2Reader::errorHandler(void) const
{
    const LibXml2ReaderPrivate* d = this->d_func();
    return d->errorhandler;
}

void LibXml2Reader::setLexicalHandler(QXmlLexicalHandler* handler)
{
    Q_D(LibXml2Reader);
    d->lexicalhandler = handler;
}

QXmlLexicalHandler* LibXml2Reader::lexicalHandler(void) const
{
    const LibXml2ReaderPrivate* d = this->d_func();
    return d->lexicalhandler;
}

void LibXml2Reader::setDeclHandler(QXmlDeclHandler* handler)
{
    Q_D(LibXml2Reader);
    d->declhandler = handler;
}

QXmlDeclHandler* LibXml2Reader::declHandler(void) const
{
    const LibXml2ReaderPrivate* d = this->d_func();
    return d->declhandler;
}

bool LibXml2Reader::parse(const QXmlInputSource& input)
{
    return this->parse(&input);
}

bool LibXml2Reader::parse(const QXmlInputSource* input)
{
    Q_D(LibXml2Reader);

    if (d->contenthandler) {
        d->contenthandler->setDocumentLocator(d->locator.data());
    }

    d->parse(input);

    return true;
}

int LibXml2ReaderLocator::columnNumber(void) const
{
    return this->reader->d_func()->context->input->col;
}

int LibXml2ReaderLocator::lineNumber(void) const
{
    return this->reader->d_func()->context->input->line;
}

Использование:

    QByteArray data;
    QXmlInputSource src;
    LibXml2Reader reader;
    QDomDocument doc;

    /* здесь читаем данные в data */

    src.setData(data);
    doc.setContent(&src, &reader);

    /* doc будет содержать дерево DOM, построенное из документа HTML */

В файл проекта нужно будет добавить две строки:

INCLUDEPATH += /usr/include/libxml2
LIBS        += -lxml2

В INCLUDEPATH помещается путь к заголовочным файлам libxml2, в LIBS — опции компилятора для подключения библиотеки libxml2.

Скачать:

© 2012 Ars Longa, Vita Brevis. Все права защищены. Перепубликация материалов без разрешения автора запрещена.

При использовании материалов блога наличие активной не закрытой от индексирования ссылки на источник обязательно.

]]> http://blog.sjinks.pro/c-cpp/qt/942-html-parser-qt/feed/ 3 OpenMP, параллельный режим и утечки памяти в GNU Standard C++ Library http://blog.sjinks.pro/c-cpp/913-openmp-parallel-mode-memory-leak-libstdc/ http://blog.sjinks.pro/c-cpp/913-openmp-parallel-mode-memory-leak-libstdc/#comments Sat, 14 May 2011 04:23:09 +0000 Vladimir http://blog.sjinks.pro/?p=913 © 2012 Ars Longa, Vita Brevis. Все права защищены. Перепубликация материалов без разрешения автора запрещена.

При использовании материалов блога наличие активной не закрытой от индексирования ссылки на источник обязательно.

]]> Скрестив ужа и ежа, Мичурин получил колючую проволоку

Стандартнуя библиотека GNU языка C++ поддерживает так называемый параллельный режим, который предоставляет экспериментальную поддержку параллельных алгоритмов из <algorithm> и <numeric>. Для включения данного режима исходный код нужно компилировать с опеределённым макросом _GLIBCXX_PARALLEL, либо явно подключать заголовочные файлы из <parallel/> и использовать пространство имён __gnu_parallel.

В параллельном режиме для реализации параллелизма используется .

Как оказалось, при использовании в своей программе OpenMP и параллельного режима libstdc++ можно столкнуться с очень неприятными и недокументированными особенностями реализации и получить незабываемое «удовольствие» при отладке.

Есть очень простая тестовая программа, использующая OpenMP:

#include <algorithm>
#include <vector>
#include <string>
#include <cstdlib>
#include <sstream>

typedef std::vector<std::string> vector_t;

template<typename T>
std::string toString(const T& x)
{
    std::stringstream converter;
    converter << x;
    return converter.str();
}

template<typename T>
T gen(void)
{
    return std::rand();
}

template<>
std::string gen(void)
{
    return toString(std::rand());
}

int main(int argc, char** argv)
{
    vector_t v1(65536);
    vector_t v2(65536);

    #pragma omp parallel shared(v1, v2)
    {
        #pragma omp single nowait
        {
            #pragma omp task shared(v1)
            std::generate(v1.begin(), v1.end(), gen<vector_t::value_type>);

            std::generate(v2.begin(), v2.end(), gen<vector_t::value_type>);
        }
    }

    return 0;
}

Программа использует два потока для заполнения двух векторов случайными строками. При использовании параллельного режима теоретически может использоваться более двух потоков — libstdc++ имеет параллельную версию алгоритма std::generate.

Сборка программы выполняется так:

g++ -fopenmp -O1 -g3 test.cpp -o test1
g++ -fopenmp -O1 -g3 -D_GLIBCXX_PARALLEL test.cpp -o test2

test1 не использует параллельный режим, test2 использует.

Самое интересное начинается при запуске обеих программ под  — с целью нахождения утечек памяти.
Запуск осуществляется так:

valgrind --num-callers=20 --leak-check=yes --leak-resolution=high --show-reachable=yes ./test1
valgrind --num-callers=20 --leak-check=yes --leak-resolution=high --show-reachable=yes ./test2

Получились такие результаты:

Без использования параллельного режима:

==10569== HEAP SUMMARY:
==10569==     in use at exit: 2,936 bytes in 6 blocks
==10569==   total heap usage: 262,152 allocs, 262,146 frees, 75,956,839 bytes allocated
…
==10569== LEAK SUMMARY:
==10569==    definitely lost: 0 bytes in 0 blocks
==10569==    indirectly lost: 0 bytes in 0 blocks
==10569==      possibly lost: 912 bytes in 3 blocks
==10569==    still reachable: 2,024 bytes in 3 blocks
==10569==         suppressed: 0 bytes in 0 blocks

Явных утечек памяти нет; по поводу still reachable разработчики говорят, что это не ошибка (я с ними согласен).

Таким образом, при использовании OpenMP и стандартного режима libstdc++ всё выглядит довольно-таки хорошо.

С использованием параллельного режима:

==10628== HEAP SUMMARY:
==10628==     in use at exit: 4,522,599 bytes in 131,078 blocks
==10628==   total heap usage: 262,402 allocs, 131,324 frees, 77,022,766 bytes allocated
…
==10628== LEAK SUMMARY:
==10628==    definitely lost: 4,519,595 bytes in 131,070 blocks
==10628==    indirectly lost: 0 bytes in 0 blocks
==10628==      possibly lost: 980 bytes in 5 blocks
==10628==    still reachable: 2,024 bytes in 3 blocks
==10628==         suppressed: 0 bytes in 0 blocks

Сразу бросается в глаза: definitely lost: 4,519,595 bytes in 131,070 blocks — это те самые два вектора (2×65536) плюс еще чуть-чуть.

Трасса вызовов выглядит так:

==10628== 34 bytes in 1 blocks are possibly lost in loss record 2 of 10
==10628==    at 0x4C28B42: operator new(unsigned long) (vg_replace_malloc.c:261)
==10628==    by 0x4ECBE6C: std::string::_Rep::_S_create(unsigned long, unsigned long, std::allocator<char> const&) (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.14)
==10628==    by 0x402FBB: char* std::string::_S_construct<char*>(char*, char*, std::allocator<char> const&, std::forward_iterator_tag) (basic_string.tcc:138)
==10628==    by 0x403002: std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string<char*>(char*, char*, std::allocator<char> const&) (basic_string.h:1649)
==10628==    by 0x403234: std::string toString<int>(int const&) (sstream:127)
==10628==    by 0x401CBD: std::string gen<std::string>() (test.cpp:27)
==10628==    by 0x402373: _ZN14__gnu_parallel46__for_each_template_random_access_workstealingIN9__gnu_cxx17__normal_iteratorIPSsNSt9__cxx19986vectorISsSaISsEEEEEPFSsvENS_19__generate_selectorIS8_EENS_12_DummyReductEbEET0_T_SF_SE_RT1_T2_T3_RSJ_NSt15iterator_traitsISF_E15difference_typeE.omp_fn.4 (for_each_selectors.h:77)
==10628==    by 0x40D68B: std::string (*__gnu_parallel::__for_each_template_random_access_workstealing<__gnu_cxx::__normal_iterator<std::string*, std::__cxx1998::vector<std::string, std::allocator<std::string> > >, std::string (*)(), __gnu_parallel::__generate_selector<__gnu_cxx::__normal_iterator<std::string*, std::__cxx1998::vector<std::string, std::allocator<std::string> > > >, __gnu_parallel::_DummyReduct, bool>(__gnu_cxx::__normal_iterator<std::string*, std::__cxx1998::vector<std::string, std::allocator<std::string> > >, __gnu_cxx::__normal_iterator<std::string*, std::__cxx1998::vector<std::string, std::allocator<std::string> > >, std::string (*)(), __gnu_parallel::__generate_selector<__gnu_cxx::__normal_iterator<std::string*, std::__cxx1998::vector<std::string, std::allocator<std::string> > > >&, __gnu_parallel::_DummyReduct, bool, bool&, std::iterator_traits<__gnu_cxx::__normal_iterator<std::string*, std::__cxx1998::vector<std::string, std::allocator<std::string> > > >::difference_type))() (workstealing.h:297)
==10628==    by 0x40D77C: std::string (*__gnu_parallel::__for_each_template_random_access<__gnu_cxx::__normal_iterator<std::string*, std::__cxx1998::vector<std::string, std::allocator<std::string> > >, std::string (*)(), __gnu_parallel::__generate_selector<__gnu_cxx::__normal_iterator<std::string*, std::__cxx1998::vector<std::string, std::allocator<std::string> > > >, __gnu_parallel::_DummyReduct, bool>(__gnu_cxx::__normal_iterator<std::string*, std::__cxx1998::vector<std::string, std::allocator<std::string> > >, __gnu_cxx::__normal_iterator<std::string*, std::__cxx1998::vector<std::string, std::allocator<std::string> > >, std::string (*)(), __gnu_parallel::__generate_selector<__gnu_cxx::__normal_iterator<std::string*, std::__cxx1998::vector<std::string, std::allocator<std::string> > > >&, __gnu_parallel::_DummyReduct, bool, bool&, std::iterator_traits<__gnu_cxx::__normal_iterator<std::string*, std::__cxx1998::vector<std::string, std::allocator<std::string> > > >::difference_type, __gnu_parallel::_Parallelism))() (for_each.h:86)
==10628==    by 0x40D814: void std::__parallel::__generate_switch<__gnu_cxx::__normal_iterator<std::string*, std::__cxx1998::vector<std::string, std::allocator<std::string> > >, std::string (*)()>(__gnu_cxx::__normal_iterator<std::string*, std::__cxx1998::vector<std::string, std::allocator<std::string> > >, __gnu_cxx::__normal_iterator<std::string*, std::__cxx1998::vector<std::string, std::allocator<std::string> > >, std::string (*)(), std::random_access_iterator_tag, __gnu_parallel::_Parallelism) (algo.h:1556)
==10628==    by 0x40258C: main.omp_fn.1 (algo.h:1584)
==10628==    by 0x53C1A12: ??? (in /usr/lib/x86_64-linux-gnu/libgomp.so.1.0.0)
==10628==    by 0x53C3748: ??? (in /usr/lib/x86_64-linux-gnu/libgomp.so.1.0.0)
==10628==    by 0x53C1FBD: ??? (in /usr/lib/x86_64-linux-gnu/libgomp.so.1.0.0)
==10628==    by 0x57E4D8B: start_thread (pthread_create.c:304)
==10628==    by 0x5AE204C: clone (clone.S:112)
==10628== 2,259,752 bytes in 65,534 blocks are definitely lost in loss record 9 of 10
==10628==    at 0x4C28B42: operator new(unsigned long) (vg_replace_malloc.c:261)
==10628==    by 0x4ECBE6C: std::string::_Rep::_S_create(unsigned long, unsigned long, std::allocator<char> const&) (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.14)
==10628==    by 0x402FBB: char* std::string::_S_construct<char*>(char*, char*, std::allocator<char> const&, std::forward_iterator_tag) (basic_string.tcc:138)
==10628==    by 0x403002: std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string<char*>(char*, char*, std::allocator<char> const&) (basic_string.h:1649)
==10628==    by 0x403234: std::string toString<int>(int const&) (sstream:127)
==10628==    by 0x401CBD: std::string gen<std::string>() (test.cpp:27)
==10628==    by 0x402373: _ZN14__gnu_parallel46__for_each_template_random_access_workstealingIN9__gnu_cxx17__normal_iteratorIPSsNSt9__cxx19986vectorISsSaISsEEEEEPFSsvENS_19__generate_selectorIS8_EENS_12_DummyReductEbEET0_T_SF_SE_RT1_T2_T3_RSJ_NSt15iterator_traitsISF_E15difference_typeE.omp_fn.4 (for_each_selectors.h:77)
==10628==    by 0x40D68B: std::string (*__gnu_parallel::__for_each_template_random_access_workstealing<__gnu_cxx::__normal_iterator<std::string*, std::__cxx1998::vector<std::string, std::allocator<std::string> > >, std::string (*)(), __gnu_parallel::__generate_selector<__gnu_cxx::__normal_iterator<std::string*, std::__cxx1998::vector<std::string, std::allocator<std::string> > > >, __gnu_parallel::_DummyReduct, bool>(__gnu_cxx::__normal_iterator<std::string*, std::__cxx1998::vector<std::string, std::allocator<std::string> > >, __gnu_cxx::__normal_iterator<std::string*, std::__cxx1998::vector<std::string, std::allocator<std::string> > >, std::string (*)(), __gnu_parallel::__generate_selector<__gnu_cxx::__normal_iterator<std::string*, std::__cxx1998::vector<std::string, std::allocator<std::string> > > >&, __gnu_parallel::_DummyReduct, bool, bool&, std::iterator_traits<__gnu_cxx::__normal_iterator<std::string*, std::__cxx1998::vector<std::string, std::allocator<std::string> > > >::difference_type))() (workstealing.h:297)
==10628==    by 0x40D77C: std::string (*__gnu_parallel::__for_each_template_random_access<__gnu_cxx::__normal_iterator<std::string*, std::__cxx1998::vector<std::string, std::allocator<std::string> > >, std::string (*)(), __gnu_parallel::__generate_selector<__gnu_cxx::__normal_iterator<std::string*, std::__cxx1998::vector<std::string, std::allocator<std::string> > > >, __gnu_parallel::_DummyReduct, bool>(__gnu_cxx::__normal_iterator<std::string*, std::__cxx1998::vector<std::string, std::allocator<std::string> > >, __gnu_cxx::__normal_iterator<std::string*, std::__cxx1998::vector<std::string, std::allocator<std::string> > >, std::string (*)(), __gnu_parallel::__generate_selector<__gnu_cxx::__normal_iterator<std::string*, std::__cxx1998::vector<std::string, std::allocator<std::string> > > >&, __gnu_parallel::_DummyReduct, bool, bool&, std::iterator_traits<__gnu_cxx::__normal_iterator<std::string*, std::__cxx1998::vector<std::string, std::allocator<std::string> > > >::difference_type, __gnu_parallel::_Parallelism))() (for_each.h:86)
==10628==    by 0x40D814: void std::__parallel::__generate_switch<__gnu_cxx::__normal_iterator<std::string*, std::__cxx1998::vector<std::string, std::allocator<std::string> > >, std::string (*)()>(__gnu_cxx::__normal_iterator<std::string*, std::__cxx1998::vector<std::string, std::allocator<std::string> > >, __gnu_cxx::__normal_iterator<std::string*, std::__cxx1998::vector<std::string, std::allocator<std::string> > >, std::string (*)(), std::random_access_iterator_tag, __gnu_parallel::_Parallelism) (algo.h:1556)
==10628==    by 0x402566: main.omp_fn.0 (algo.h:1584)
==10628==    by 0x40297B: main (test.cpp:35)

Ключ к пониманию даёт workstealing.h (адрес 0x40D68B в трассе). В коде есть такая строка:

  1. #     pragma omp parallel shared(__busy) num_threads(__num_threads)

Что получается: грубо говоря, следующее:

#pragma omp parallel
{
    #pragma omp single nowait
    {
        #pragma omp task
        {
            // …
            #pragma omp parallel num_threads(__num_threads)
            // …
        }
    }
}

Есть предположение, что виноват num_threads во вложенном omp parallel (по крайней мере, если убрать num_threads, то утечки исчезают — но последствия изменений я не проверял).

Вроде бы в num_threads криминала нет — вложенный блок omp parallel создаёт новую группу потоков (при условии, что вложенность разрешена — либо через OMP_NESTED=TRUE, либо через вызов omp_set_nested(true)), а не изменяет количество потоков в существующей группе, но где-то что-то не до конца продумано.

Мораль на сегодняшний день такова: при использовании OpenMP параллельный режим глобально лучше не включать; при необходимости использования параллельных алгоритмов использовать алгоритм из пространства имён __gnu_parallel (и ни в коем случае не делать этого внутри блоков OpenMP).

© 2012 Ars Longa, Vita Brevis. Все права защищены. Перепубликация материалов без разрешения автора запрещена.

При использовании материалов блога наличие активной не закрытой от индексирования ссылки на источник обязательно.

]]> http://blog.sjinks.pro/c-cpp/913-openmp-parallel-mode-memory-leak-libstdc/feed/ 2 k-путевое слияние на C++ http://blog.sjinks.pro/c-cpp/911-k-way-merge-sort-cpp/ http://blog.sjinks.pro/c-cpp/911-k-way-merge-sort-cpp/#comments Fri, 06 May 2011 11:40:48 +0000 Wandering Soul http://blog.sjinks.pro/?p=911 © 2012 Ars Longa, Vita Brevis. Все права защищены. Перепубликация материалов без разрешения автора запрещена.

При использовании материалов блога наличие активной не закрытой от индексирования ссылки на источник обязательно.

]]> Пример простейшей реализации k-путевго слиянием

Алгоритмы слияния — семейство алгоритмов, последовательно обрабатывающие отсортированные списки и генерирующие один или более отсортированных списков на выходе. Слияние используется в алгоритме сортировки слиянием (например, функция bitonic_merge() в алгоритме битонной сортировки).

k-путевое слияние использует k отсортированных списков; в данном примере генерируется один выходной список, размер которого равен размеру всех входных списков.

k-путевое слияние может быть очень эффективно при сортировке очень больших объёмов данных: большой исходный файл разбивается на несколько файлов меньшего размера, каждый из которых можно отсортировать в оперативной памяти; после сортировки получается n отсортированных файлов. Над отсортированными файлами выполняется многопутевого слияния (возможно, в несколько этапов), на выходе получается отсортированный исходный файл.

Как сортировку, так и слияние можно выполнять параллельно (например, при использовании быстрой сортировки можно использовать конструкцию task из  3.0; слияния же можно проводить в несколько потоков потоков — например, 100 файлов можно отсортировать в 4 потока, используя 25-путевое слияние — правда, это создаст дополнительную нагрузку на диск).

Ниже приведена простейшая реализация k-путевого слияния на C++.

#include <vector>
#include <algorithm>
#include <utility>
#include <functional>

template<typename InputIterator, typename OutputIterator, typename Compare>
OutputIterator n_way_merge(const std::vector<std::pair<InputIterator, InputIterator> >& in, OutputIterator out, Compare comp)
{
    OutputIterator res = out;
    typedef typename std::iterator_traits<InputIterator>::value_type value_t;
    std::vector<value_t> l(in.size());
    std::vector<std::pair<InputIterator, InputIterator> > f;
    typedef typename std::vector<std::pair<InputIterator, InputIterator> >::iterator iterator_t;

    f.assign(in.begin(), in.end());
    iterator_t b = f.begin();
    std::size_t i = 0;

    while (b != f.end()) {
        std::pair<InputIterator, InputIterator>& x = *b;
        if (x.first == x.second) {
            b = f.erase(b);
            l.erase(l.begin() + i);
        }
        else {
            l[i] = *x.first;
            ++b;
            ++i;
        }
    }

    while (!f.empty()) {
        typename std::vector<value_t>::iterator p = std::min_element(l.begin(), l.end(), comp);
        *out = *p;
        ++out;
        i = p - l.begin();
        ++f[i].first;
        if (f[i].first == f[i].second) {
            f.erase(f.begin() + i);
            l.erase(p);
        }
        else {
            l[i] = *f[i].first;
        }
    }

    return out;
}

template<typename InputIterator, typename OutputIterator>
OutputIterator n_way_merge(const std::vector<std::pair<InputIterator, InputIterator> >& in, OutputIterator out)
{
    typedef typename std::iterator_traits<InputIterator>::value_type value_t;
    return n_way_merge(in, out, std::less<value_t>());
}

Пример использования:

    int a[5] = { 10, 20, 30, 40, 50 };
    int b[8] = { 5, 7, 9, 11, 13, 15, 17, 19 };
    int c[3] = { 0, 1, 2 };
    int d[4] = { 6, 12, 18, 24 };

    std::vector<std::pair<int*, int*> > in(4);
    in.push_back(std::make_pair(a, a + 5));
    in.push_back(std::make_pair(b, b + 8));
    in.push_back(std::make_pair(c, c + 3));
    in.push_back(std::make_pair(d, d + 4));

    std::vector<int> out(5+8+3+4);

    n_way_merge(in, out.begin());
    for (std::size_t i=0; i<out.size(); ++i) {
        std::cout << out[i] << " ";
    }

    std::cout << std::endl;

© 2012 Ars Longa, Vita Brevis. Все права защищены. Перепубликация материалов без разрешения автора запрещена.

При использовании материалов блога наличие активной не закрытой от индексирования ссылки на источник обязательно.

]]> http://blog.sjinks.pro/c-cpp/911-k-way-merge-sort-cpp/feed/ 1 Bitonic Mergesort на C++ http://blog.sjinks.pro/c-cpp/908-bitonic-mergesort-cpp/ http://blog.sjinks.pro/c-cpp/908-bitonic-mergesort-cpp/#comments Sat, 16 Apr 2011 11:16:53 +0000 Vladimir http://blog.sjinks.pro/?p=908 © 2012 Ars Longa, Vita Brevis. Все права защищены. Перепубликация материалов без разрешения автора запрещена.

При использовании материалов блога наличие активной не закрытой от индексирования ссылки на источник обязательно.

]]> Битонная в стиле STL

Битонная сортировка слиянием (bitonic mergesort) — параллельный алгоритм сортировки, рекурсивно разделяющий входную последовательность на сортированные последовательности меньшего размера.

Алгоритм битонной сортировки может выполняться параллельно, потому что каждая операция разделения независима от всех других операций.

#include <iterator>
#include <functional>
#include <algorithm>

namespace {
    template<typename Iterator, typename Comp>
    void bitonic_merge(bool flag, Iterator begin, Iterator end, Iterator middle, Comp c)
    {
        Iterator x(begin);
        Iterator y(middle);

        for ( ; y != end; ++x, ++y) {
            if (flag != c(*x, *y)) {
                std::swap(*x, *y);
            }
        }

        x = begin;
        y = middle;
        typename std::iterator_traits<Iterator>::difference_type halfsize = std::distance(begin, middle) >> 1;
        if (halfsize) {
            std::advance(x, halfsize);
            std::advance(y, halfsize);

            bitonic_merge(flag, begin, middle, x, c);
            bitonic_merge(flag, middle, end, y, c);
        }
    }

    template<typename Iterator, typename Comp>
    void bitonic_sort_private(bool flag, Iterator begin, Iterator end, Comp c)
    {
        typename std::iterator_traits<Iterator>::difference_type size = std::distance(begin, end);
        if (size <= 1) {
            return;
        }

        Iterator m(begin);
        std::advance(m, size >> 1);

        bitonic_sort_private(flag, begin, m, c);
        bitonic_sort_private(!flag, m, end, c);

        bitonic_merge(flag, begin, end, m, c);
    }

};

template<typename Iterator>
void bitonic_sort(Iterator begin, Iterator end)
{
    typedef typename std::iterator_traits<Iterator>::value_type value_t;
    bitonic_sort_private(true, begin, end, std::less<value_t>());
}

template<typename Iterator, typename Comp>
void bitonic_sort(Iterator begin, Iterator end, Comp c)
{
    bitonic_sort_private(true, begin, end, c);
}

© 2012 Ars Longa, Vita Brevis. Все права защищены. Перепубликация материалов без разрешения автора запрещена.

При использовании материалов блога наличие активной не закрытой от индексирования ссылки на источник обязательно.

]]> http://blog.sjinks.pro/c-cpp/908-bitonic-mergesort-cpp/feed/ 1 Пример рабочей реализации QDomDocument::elementById http://blog.sjinks.pro/c-cpp/qt/906-working-qdomdocument-elementbyid/ http://blog.sjinks.pro/c-cpp/qt/906-working-qdomdocument-elementbyid/#comments Sat, 19 Mar 2011 13:52:03 +0000 Vladimir http://blog.sjinks.pro/?p=906 © 2012 Ars Longa, Vita Brevis. Все права защищены. Перепубликация материалов без разрешения автора запрещена.

При использовании материалов блога наличие активной не закрытой от индексирования ссылки на источник обязательно.

]]> Избавляемся от ошибки «elementById() is not implemented and will always return a null node»

Так сложилось, что в реализация метода QDomDocument::elementById() нерабочая: при попытке использования данного метода выдаётся предупреждение elementById() is not implemented and will always return a null node и возвращается пустой элемент .

Временами это очень неудобно: например, вместо использования из QXmlPatterns может быть проще получить элемент DOM по его id и пройтись по его потомкам. А при использовании XPath функцию id() использовать не получится в силу тех же причин.

Ниже приведён пример рабочей реализации QDomDocument::elementById().

#include <QtXml/QDomDocument>
#include <QMap>

class QMyDomDocument : public QDomDocument {
public:
    QMyDomDocument() : QDomDocument() {}
    QMyDomDocument(const QString& name) : QDomDocument(name) {}
    QMyDomDocument(const QDomDocumentType& doctype) : QDomDocument(doctype) {}

    QDomElement elementById(const QString& id)
    {
        if (map.contains(id)) {
            QDomElement e = map[id];
            if (e.parentNode().nodeType() != QDomNode::BaseNode) {
                return e;
            }

            map.remove(id);
        }

        bool res = this->find(this->documentElement(), id);
        if (res) {
            return map[id];
        }

        return QDomElement();
    }

private:
    QMap<QString, QDomElement> map;

    bool find(QDomElement node, const QString& id)
    {
        if (node.hasAttribute("id")) {
            QString value = node.attribute("id");
            this->map[value] = node;
            if (value == id) {
                return true;
            }
        }

        for (unsigned int i=0; i<node.childNodes().length(); ++i) {
            QDomNode n = node.childNodes().at(i);
            if (n.isElement()) {
                bool res = this->find(n.toElement(), id);
                if (res) {
                    return true;
                }
            }
        }

        return false;
    }
};

Один из тонких моментов реализации — определение принадлежности вершины документу. Так как для ускорения поиска используется отображение <id, элемент>, может возникнуть ситуация, когда запрашиваемый элемент уже удалён из документа (в результате в отображении остаются неактуальные данные).

Если удалить элемент из документа, он «лишается» родителя — в результате его родительская (псевдо)вершина имеет тип QDomNode::BaseNode. Это свойство и используется для определения актуальности элемента.

© 2012 Ars Longa, Vita Brevis. Все права защищены. Перепубликация материалов без разрешения автора запрещена.

При использовании материалов блога наличие активной не закрытой от индексирования ссылки на источник обязательно.

]]> http://blog.sjinks.pro/c-cpp/qt/906-working-qdomdocument-elementbyid/feed/ 4 Scope Guard средствами C++0x: часть 2 http://blog.sjinks.pro/c-cpp/800-scope-guard-cpp-0x-part-2/ http://blog.sjinks.pro/c-cpp/800-scope-guard-cpp-0x-part-2/#comments Mon, 26 Apr 2010 18:40:44 +0000 Vladimir http://blog.sjinks.pro/?p=800 © 2012 Ars Longa, Vita Brevis. Все права защищены. Перепубликация материалов без разрешения автора запрещена.

При использовании материалов блога наличие активной не закрытой от индексирования ссылки на источник обязательно.

]]> Более глубокое погружение в

В прошлой части была рассмотрена реализация Scope Guard средствами C++0x. Благодаря шаблонам с переменным количеством параметров (variadic templates), реализация на C++0x получилась несколько проще, чем в оригинале, так как один и тот же шаблонный класс может использоваться для создания с различным количеством параметров.

Но, как было отмечено, предыдущая реализация не являлась оптимальной в плане количества строк. Можно сделать проще и короче.

Одна из проблем предыдущей реализации — необходимость наличия отдельного класса, если Scope Guard потребуется вызывать метод какого-либо класса.

Иными словами, требуется две реализации: одна для Scope Guard, работающего с обычными функциями, другая — для Scope Guard, работающего с методами. Как оказалось, данная проблема решаема.

Основную (на мой взгляд) неочевидность в коде создавал метод развёртки std::tuple (Apply_Helper).

Хорошая новость заключается в том, что благодаря std::bind() обе проблемы очень легко решаются.

Реализация XGuard теперь сильно упрощается:

template<typename Function>
class XGuard {
public:
    XGuard(Function aFunction)
        : m_fSucceeded{false}, m_Function(aFunction)
    {
    }

    ~XGuard(void)
    {
        if (!this->m_fSucceeded) {
            try {
                this->m_Function();
            }
            catch(...) {
            }
        }
    }

    XGuard(const XGuard&& other) : m_fSucceeded(other.m_fSucceeded), m_Function(other.m_Function)
    {
        other.commit();
    }

    void commit(void) const throw()
    {
        this->m_fSucceeded = true;
    }

private:
    mutable bool m_fSucceeded;
    Function m_Function;

    XGuard(const XGuard&) = delete;
    XGuard& operator=(const XGuard&) = delete;
};

А благодаря type inference очень легко написать функцию, которая будет создавать XGuard:

template<typename F, typename... A>
auto makeXGuard(F f, const A&&... p) -> XGuard<decltype(std::bind(f, p...))>
{
    auto func = std::bind(f, p...);
    return XGuard<decltype(func)>(func);
}

Фокус в том, что передавая в функцию parameter pack (который const A&&... p), мы не можем априорно знать, какой результат вернёт std::bind() для таких аргументов. Использование вывода типов и альтернативный синтаксис функций приходят на помощь, в результате чего мы получили такой код.

Для возможности работы с методами классов нужно создать еще один вариант makeXGuard():

template<typename C, typename M, typename... A>
auto makeXGuard(C& c, M m, const A&&... p) -> XGuard<decltype(std::bind(m, c, p...))>
{
    auto func = std::bind(m, c, p...);
    return XGuard<decltype(func)>(func);
}

Вот так всё просто.

© 2012 Ars Longa, Vita Brevis. Все права защищены. Перепубликация материалов без разрешения автора запрещена.

При использовании материалов блога наличие активной не закрытой от индексирования ссылки на источник обязательно.

]]> http://blog.sjinks.pro/c-cpp/800-scope-guard-cpp-0x-part-2/feed/ 4 Scope Guard средствами C++0x: часть 1 http://blog.sjinks.pro/c-cpp/796-scope-guard-by-means-of-cpp-0x-part-1/ http://blog.sjinks.pro/c-cpp/796-scope-guard-by-means-of-cpp-0x-part-1/#comments Fri, 23 Apr 2010 08:26:51 +0000 Vladimir http://blog.sjinks.pro/?p=796 © 2012 Ars Longa, Vita Brevis. Все права защищены. Перепубликация материалов без разрешения автора запрещена.

При использовании материалов блога наличие активной не закрытой от индексирования ссылки на источник обязательно.

]]> Часть первая: решение в лоб

Scope Guard — одно из средств автоматического освобождения ресурсов при выходе за пределы видимости переменной, с ними связанной. предоставляет базовую гарантию безопасности исключений. Авторами этой идеи (по-видимому) являются Andrei Alexandrescu и Petru Marginean. Если вы с этой статьёй еще не знакомы, то очень рекомендую к прочтению.

Реализация Scope Guard довольно простая, но из-за того, что C++ не поддерживал шаблоны с переменным количеством параметров, приходилось создавать несколько шаблонов — в зависимости от того, сколько аргументов принимает функция, выполняющая освобождение ресурсов.

В добавлена поддержка шаблонов с переменным количеством параметров (variadic templates). Мне было интересно переписать Scope Guard одним шаблоном — хорошее погружение в новые возможности языка.

Получился примерно такой код (он не самый оптимальный в плане количества строк, можно написать проще, но об этом в следующей части):

#ifndef SJ_XGUARD_H_
#define SJ_XGUARD_H_

#include <tuple>

namespace {
    template<unsigned int N>
    struct Apply_Helper {
        template<typename F, typename... ArgsT, typename... Args>
        static void apply(const F& f, const std::tuple<ArgsT...>&& t, Args&&... args)
        {
            Apply_Helper<N-1>::apply(f, t, std::get<N-1>(t), args...);
        }
    };

    template<>
    struct Apply_Helper<0> {
        template<typename F, typename... ArgsT, typename... Args>
        static void apply(const F& f, const std::tuple<ArgsT...>&&, Args&&... args)
        {
            f(args...);
        }
    };

    template<typename F, typename... ArgsT>
    void apply(const F& f, std::tuple<ArgsT...> const&& t)
    {
        Apply_Helper<sizeof...(ArgsT)>::apply(f, t);
    }
};

template<typename Function, typename... Args>
class XGuard {
public:
    XGuard(const Function& aFunction, std::tuple<Args...>&& aParams)
        : m_fSucceeded(false),
          m_Function(aFunction),
          m_Params(aParams)
    {
    }

    ~XGuard(void) throw()
    {
        if (!this->m_fSucceeded) {
            try {
                apply(this->m_Function, this->m_Params);
            }
            catch(...) {
            }
        }
    }

    XGuard(XGuard&& other)
        : m_fSucceeded(other.m_fSucceeded),
          m_Function(other.m_Function),
          m_Params(other.m_Params)
    {
        other.commit();
    }

    void commit(void) const throw()
    {
        this->m_fSucceeded = true;
    }

    XGuard& operator=(XGuard&& other)
    {
        if (&other != this) {
            this->m_fSucceeded = other.m_fSucceeded;
            this->m_Function   = other.m_Function;
            this->m_Params     = std::move(other.m_Params);

            other.m_Function = NULL;
            other.commit();
        }

        return *this;
    }

    XGuard(const XGuard& other) = delete;
    XGuard& operator=(const XGuard& other) = delete;
private:
    mutable bool m_fSucceeded;
    Function m_Function;
    std::tuple<Args...>&& m_Params;
};

template<typename F, typename... A>
inline XGuard<F, A...> makeXGuard(const F& f, std::tuple<A...>&& p)
{
    return XGuard<F, A...>(f, p);
}

#define MAKEXGUARD(f, ...) \
    makeXGuard((f), std::make_tuple(__VA_ARGS__))

#endif /* SJ_XGUARD_H_ */

Название XGuard чисто историческое, я в университете занимался «велосипедостроительством», поэтому просто переделал код многолетней давности.

Основной трудностью для меня было развернуть std::tuple в список параметров. Отвык программировать на Prolog :-( Развёрткой std::tuple в список параметров занимается Apply_Helper в анонимном пространстве имён. Для программировавших на чем-нибудь типа Prolog принцип очень простой:

Apply_Helper<N>::apply([tuple_head|tuple_tail], [params]) => Apply_Helper<N-1>::apply([tuple_tail], [tuple_head|params])

Другой подводный камень — макро MAKEXGUARD. Дело в том, что такая реализация:

template<typename F, typename... A>
inline XGuard<F, A...> makeXGuard(const F& f, const A&& p)
{
    return XGuard<F, A...>(f, std::make_tuple(p));
}

не воспринимает std::ref()/std::cref() в списках параметров — у компилятора не получается определить корректный шаблон на основе вывода параметров.

Как я уже говорил, приведённый код не является оптимальным в плане количества строк (можно сделать проще), но не генерирует лишнего машинного кода. Вся свёртка/развёртка параметров производится на этапе компиляции.

Например, такой код:

#include <cstdlib>
//#include <iostream>
#include <functional>
#include "xguard.h"

static void my_free(void*& p)
{
    if (p) {
        free(p);
        p = NULL;
    }
}

int main(int, char**)
{
    {
        void* p = (void*)std::malloc(100);
//      std::cout << p << std::endl;
        auto guard = MAKEXGUARD(&my_free, std::ref(p));
//      std::cout << p << std::endl;
    }

    return 0;
}

транслируется в такой:

main:
    sub rsp, 24
    mov edi, 100
    call    malloc          ; void* p = (void*)std::malloc(100);
    lea rdi, [rsp+8]
    mov QWORD PTR [rsp+8], rax
    call    _ZL7my_freeRPv      ; my_free(p);
    xor eax, eax
    add rsp, 24
    ret

_ZL7my_freeRPv:
    push    rbx
    mov rbx, rdi
    mov rdi, QWORD PTR [rdi]
    test    rdi, rdi
    je  .L5
    call    free
    mov QWORD PTR [rbx], 0
.L5:
    pop rbx
    ret

Таким образом, вызов функции makeXGuard() и конструктора XGuard::XGuard() вообще не генерирует никакого кода! А при выходе p из области видимости автоматически генерируется вызов my_free(p) (то есть то же самое, что и написал бы программист, не использующий Scope Guard). Иными словами, накладных расходов нет. Красота!

© 2012 Ars Longa, Vita Brevis. Все права защищены. Перепубликация материалов без разрешения автора запрещена.

При использовании материалов блога наличие активной не закрытой от индексирования ссылки на источник обязательно.

]]> http://blog.sjinks.pro/c-cpp/796-scope-guard-by-means-of-cpp-0x-part-1/feed/ 2 Патч для php-cgi, позволяющий конфигурировать значение listen backlog http://blog.sjinks.pro/php/747-php-cgi-patch-to-configure-listen-backlog/ http://blog.sjinks.pro/php/747-php-cgi-patch-to-configure-listen-backlog/#comments Sun, 03 Jan 2010 06:19:20 +0000 Vladimir http://blog.sjinks.pro/?p=747 © 2012 Ars Longa, Vita Brevis. Все права защищены. Перепубликация материалов без разрешения автора запрещена.

При использовании материалов блога наличие активной не закрытой от индексирования ссылки на источник обязательно.

]]> Задание listen backlog через переменную окружения _FCGI_LISTEN_BACKLOG

По умолчанию значение listen backlog в php-cgi жёстко задано — 128. Это означает, что PHP не сможет обработать более 128 запросов одновременно (точнее, что очередь запросов не сможет превысить данного значения). Я столкнулся с тем, что 128 — это мало.

Для тех, кто столкнулся с данной проблемой, но по каким-либо причинам не хочет/не может поставить php-fpm (в котором backlog конфигурируется), я сделал небольшой .

--- php.orig/sapi/cgi/cgi_main.c.orig   2009-06-09 13:29:39.000000000 +0000
+++ php/sapi/cgi/cgi_main.c 2010-01-03 04:44:34.000000000 +0000
@@ -1523,7 +1523,15 @@
 
 #if PHP_FASTCGI
    if (bindpath) {
-       fcgi_fd = fcgi_listen(bindpath, 128);
+       int backlog = 128;
+       if (getenv("PHP_FCGI_LISTEN_BACKLOG")) {
+           backlog = atoi(getenv("PHP_FCGI_LISTEN_BACKLOG"));
+           if (backlog < 0) {
+               backlog = 128;
+           }
+       }
+
+       fcgi_fd = fcgi_listen(bindpath, backlog);
        if (fcgi_fd < 0) {
            fprintf(stderr, "Couldn't create FastCGI listen socket on port %s\n", bindpath);
 #ifdef ZTS

Применять к файлу sapi/cgi/cgi_main.c.

Что даёт: значение backlog можно задавать в переменной окружения PHP_FCGI_LISTEN_BACKLOG.

Проверялось на PHP 5.2.10-2ubuntu6.3 (Ubuntu 9.10).

Установка в Debian/Ubuntu:

mkdir php && cd php
apt-get source php5-cgi
sudo apt-get install devscripts build-essential wget
sudo apt-get build-dep php5-cgi
cd php5-*
QUILT_PATCHES=debian/patches quilt --quiltrc /dev/null push -a
wget http://d.sjinks.pro/listen-backlog-env-var.patch -O debian/patches/listen-backlog-env-var.patch
QUILT_PATCHES=debian/patches quilt --quiltrc /dev/null import debian/patches/listen-backlog-env-var.patch
QUILT_PATCHES=debian/patches quilt --quiltrc /dev/null push -a
QUILT_PATCHES=debian/patches quilt --quiltrc /dev/null pop -a
debuild clean
debuild -i -us -uc -b

Практические результаты: при помощи ab генерировалась сильная нагрузка (DoS) на сервер (10,000 запросов в 200 параллельных потоков):

ab -n 10000 -c 200 http://example.com/

Стандартный PHP смог обработать 2,275 запросов из 10,000 — остальные запросы были отвергнуты (502 Bad Gateway).

После применения патча и

echo 2048 > /proc/sys/net/core/somaxconn
export PHP_FCGI_LISTEN_BACKLOG=1024

и перезапуска, PHP смог обработать все запросы.

Изменилось всего-то 9 строк кода, а какой результат!

© 2012 Ars Longa, Vita Brevis. Все права защищены. Перепубликация материалов без разрешения автора запрещена.

При использовании материалов блога наличие активной не закрытой от индексирования ссылки на источник обязательно.

]]> http://blog.sjinks.pro/php/747-php-cgi-patch-to-configure-listen-backlog/feed/ 10 Модуль поддержки tcpwrappers для nginx http://blog.sjinks.pro/security/654-tcpwrappers-support-for-nginx/ http://blog.sjinks.pro/security/654-tcpwrappers-support-for-nginx/#comments Sat, 10 Oct 2009 01:15:47 +0000 Vladimir http://blog.sjinks.pro/?p=654 © 2012 Ars Longa, Vita Brevis. Все права защищены. Перепубликация материалов без разрешения автора запрещена.

При использовании материалов блога наличие активной не закрытой от индексирования ссылки на источник обязательно.

]]> Использование для контроля доступа

 — система контроля доступа, используемая для ограничения доступа к серверам на UNIX-подобных операционных системах (, BSD). Контроль доступа может осуществляться, например, по имени хоста (полному или частичному), адресу, подсети. Подробности приведены здесь.

TCP Wrappers очень удобно использовать с программами для защиты от червей (BlackHosts, DenyHosts, Fail2ban), в частности, для защиты от HTTP-сканирования.

Огромным достоинством TCP Wrappers является возможность динамической конфигурации списков контроля доступа (что избавляет от необходимости перезапускать защищаемый сервис) и простота файлов конфигурации (это субъективно).

К сожалению, не поддерживает TCP Wrappers из коробки. К счастью, это можно исправить.

Заказчик, для которого писался данный модуль, не возражал против выкладывания исходного кода модуля в общий доступ, чем я и воспользовался.

Прежде, чем перейти непосредственно к модулю, отмечу, что у TCP Wrappers есть несколько особенностей дизайна, о которых нужно знать:

  • самое большое моё разочарование заключается в том, что libwrap (библиотека, реализующая функциональность TCP Wrappers) не является библиотекой с потоковой безопасностью (thread safety). Иными словами, если два потока одновременно обратятся к libwrap, результат может получиться весьма странным. Это связано с тем, что libwrap использует нереентера́бельные (какое слово! но по-английски звучит лучше) функции, например, strtok(), gethostbyname(), gethostbyaddr() и т.п. Если nginx собран с поддержкой многопоточности, то на нагруженных серверах использование libwrap может привести к потерям производительности (из-за того, что доступ к функциям libwrap должен быть последовательным — приходится использовать мьютекс). Если же nginx собирался без поддержки многопоточности (как, например, в Linux), то такая проблема не возникает;
  • динамическая конфигурация списков контроля доступа имеет свою цену: при каждом запросе будут читаться и разбираться файлы /etc/hosts.allow и /etc/hosts.deny, что на высоконагруженных серверах может быть неприемлемо.

Сборка модуля

Переходим непосредственно к модулю. Так как nginx не поддерживает динамические модули, nginx придётся пересобирать из исходного кода. Предполагая, что исходный код nginx находится в ~/nginx, исходный код модуля  — в ~/nginx/ngx_tcpwrappers, выглядеть это всё будет примерно так:

cd ~/nginx
./configure \
    --conf-path=/etc/nginx/nginx.conf \
    --error-log-path=/var/log/nginx/error.log \
    # здесь идут остальные параметры, передаваемые configure \
    --add-module=./ngx_tcpwrappers
make
sudo make install

Конфигурация модуля

Директивы конфигурации:

Синтаксис: tcpwrappers [on|off]
По умолчанию: tcpwrappers off
Контекст: http, server, location, limit_except
Описание: данная директива разрешает либо запрещает использование TCP Wrappers для контроля доступа к ресурсу. tcpwrappers off полностью отключает использование TCP Wrappers, что позволяет избежать потерь производительности.

Синтаксис: tcpwrappers_daemon name
По умолчанию: tcpwrappers_daemon nginx
Контекст: http, server, location, limit_except
Описание: данная директива позволяет задать имя демона, которое используется в файлах /etc/hosts.{allow,deny} для идентификации процесса.

Синтаксис: tcpwrappers_thorough [on|off]
По умолчанию: tcpwrappers_thorough off
Контекст: http, server, location, limit_except
Описание: данная директива управляет тщательностью проверки клиента.

При tcpwrappers_thorough off используется функция hosts_ctl(3); контроль осуществляется исключительно по IP-адресу клиента (в том плане, что libwrap передаётся только IP-адрес).

При tcpwrappers_thorough on используется функция hosts_access(3); контроль может осуществляться по адресу и имени клиента и сервера. Данная проверка является более тщательной, но имеет свою цену: необходимость выполнения DNS-запросов для получения имени клиента и сервера.

Исходный код

Исходный код модуля ngx_tcpwrappers

© 2012 Ars Longa, Vita Brevis. Все права защищены. Перепубликация материалов без разрешения автора запрещена.

При использовании материалов блога наличие активной не закрытой от индексирования ссылки на источник обязательно.

]]> http://blog.sjinks.pro/security/654-tcpwrappers-support-for-nginx/feed/ 2 ngx_drop_privs: принцип минимальных привилегий в nginx http://blog.sjinks.pro/security/648-ngx_drop_privs-minimum-privilege-principle-nginx/ http://blog.sjinks.pro/security/648-ngx_drop_privs-minimum-privilege-principle-nginx/#comments Wed, 23 Sep 2009 02:35:11 +0000 Vladimir http://blog.sjinks.pro/?p=648 © 2012 Ars Longa, Vita Brevis. Все права защищены. Перепубликация материалов без разрешения автора запрещена.

При использовании материалов блога наличие активной не закрытой от индексирования ссылки на источник обязательно.

]]> Забираем у лишние привилегии

nginx — замечательный web-сервер, но, как и практически любой программный продукт, не свободен от ошибок, временами весьма критических.

Архитектура nginx такова, что обычно имеется один привилегированный процесс (запускаемый от всемогущего root) и один или более рабочих процессов (обычно работающих от имени непривилегированного пользователя). Тем не менее, я видел конфигурации, в которых все процессы nginx работают под привилегированным пользователем. Один из примеров — многопользовательский сервер, Document Root сайтов на котором имеет права вида 0700 (запускать несколько nginx и настраивать проксирование — тоже не лучший выход).

Кроме того, за последние неполные пять лет в nginx найдено 112 ошибок (segmentation fault), некоторые из которых теоретически могут дать возможность выполнения произвольного кода в системе (wget http://sysoev.ru/nginx/changes.html -q -O - | grep segmentation | wc -l).

Я не знаю, все ли ошибки затрагивали только рабочие процессы, либо были ошибки в главном процессе — рисковать не хочется. Так и родилась идея написать модуль для nginx — .

Данный модуль будет работать, скорее всего, только под , при этом для работы требуется наличие библиотеки libcap и ядра, собранного с поддержкой capabilities (я давно не видел ядра без такой поддержки).

Идея заключается в том, что процессу, который порождает потомков, меняет их UID/GID и периодически меняет владельца log-файлов, привилегий root слишком много. Вполне достаточно CAP_SETUID, CAP_SETGID и CAP_CHOWN (если нужна ротация логов).

CAP_CHOWN — весьма опасная возможность, и если есть возможность её не давать, лучше её не давать :-)

Модуль при инициализации проверяет, запущен ли главный процесс от имени root. Если да, то capabilities сбрасываются на указанные в директиве dropprivs_set_caps.

Директива dropprivs_set_caps является глобальной (как, например, daemon, user и pid) и имеет формат

dropprivs_set_caps "строка";

где строка — привилегии в формате, который понимает функция cap_from_text(). Никто не говорил, что будет легко.

На своей тестовой машине я использую такое значение:

dropprivs_set_caps "cap_setuid,cap_setgid=ep";

Это равносильно сбросу всех привилегий и установке CAP_SETUID и CAP_SETGID в действующем (effective) и разрешённом (permitted) наборе привилегий.

Те, кому это всё интересно, могут скачать исходный код модуля ngx_drop_privs. Код пока ещё сыроват (да, написан за полтора часа этой ночью) и будет совершенствоваться. Любые предложения/патчи are always welcome. Планируется поддержка chroot, что позволит меньше беспокоиться о CAP_CHOWN и CAP_SETUID.

UPDATE 16.02.2010: добавлена экспериментальная поддержка chroot. Реализуется глобальной директивой

dropprivs_chroot "каталог";

Выполняется chroot() до сброса привилегий, поэтому явным образом указывать CAP_SYS_CHROOT в списке разрешённых привилегий не нужно (и вообще не рекомендуется). Перед вызовом chroot() выполняется chdir() в указанный каталог, поэтому если привилегии настроены нормально, покинуть chroot демон не сможет. Тем не менее, это накладывает свои ограничения:

  • пути в виртуальных хостах должны быть относительны нового корня;
  • в новом корне должен существовать как минимум /dev/zero;
  • PID-файл создаётся относительно нового корня;
  • что происходит с лог-файлами, пока сказать не могу, но есть подозрение что ротация логов без танцев с бубном работать не будет.

Сборка модуля:

cd /path/to/nginx/source
./configure \ # Здесь идут обычные опции configure
    --add-module=/path/to/ngx_drop_privs
make

© 2012 Ars Longa, Vita Brevis. Все права защищены. Перепубликация материалов без разрешения автора запрещена.

При использовании материалов блога наличие активной не закрытой от индексирования ссылки на источник обязательно.

]]> http://blog.sjinks.pro/security/648-ngx_drop_privs-minimum-privilege-principle-nginx/feed/ 3