Ars Longa, Vita Brevis » C/C++ http://blog.sjinks.pro Quod scripsi, scripsi Sat, 19 May 2012 17:55:07 +0000 ru-RU hourly 1 Отслеживание источника исключения в С++ http://blog.sjinks.pro/c-cpp/969-track-uncaught-exceptions/ http://blog.sjinks.pro/c-cpp/969-track-uncaught-exceptions/#comments Mon, 30 Apr 2012 02:50:20 +0000 Vladimir http://blog.sjinks.pro/?p=969 © 2012 Ars Longa, Vita Brevis. Все права защищены. Перепубликация материалов без разрешения автора запрещена.

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

]]> Лезем в глубокие дебри C++ и его ABI

Обобщённая версия статьи «Отслеживание источника исключения в Qt».

Решение проблемы отлова не пойманного исключения при помощи gdb — задача не из приятных, особенно при отладке многопоточных приложений. К счастью, есть и более простой способ.

Чтобы понять, как организована работа с исключениями на уровне стандартной библиотеки, нужно тщательно выкурить ABI языка C++, в частности, главу, посвящённую обработке исключений.

Из всей главы нам интересны две функции:

  1. void __cxa_throw (void *thrown_exception, std::type_info *tinfo, void (*dest) (void *) );
  2. void __cxa_rethrow ();

Первая функция кидает исключение (thrown_exception — кидаемое исключение, tinfo — указатель на информацию о типе исключения (тип std::type_info определён в заголовке <typeinfo>), dest — указатель на деструктор исключения). В принципе, единственное, что нам может быть полезно — это tinfo: tinfo->name() даст нам имя типа исключения.

Имя исключения будет иметь вид St13runtime_error (mangled name); для декодирования можно использовать функцию

extern "C" char* abi::__cxa_demangle (const char* mangled_name, char* buf, size_t* n, int* status);

char* demangled = abi:: __cxa_demangle(tinfo->name(), 0, 0, 0);
std::cerr << "Thrown exception of type " << (demangled ? demangled : tinfo->name()) << std::endl;
if (demangled) {
    std::free(demangled);
}

При большом желании можно проверить, наследуется ли брошенное исключение от std::exception; если да, то можно вывести на экран значение exception::what(). Проблема здесь в том, что thrown_exception типа void* — как следствие, dynamic_cast не сработает. Поэтому для такой магии придётся разбираться, как работает dynamic_cast.

Если вкратце, на помощь приходит функция

extern "C" void* __dynamic_cast (const void *sub, const abi::__class_type_info *src, const abi::__class_type_info *dst, std::ptrdiff_t src2dst_offset);

Алгоритм тут такой:

  1. Проверить, является ли tinfo экземпляром класса abi::__class_type_info; если нет, то брошенное исключение — не объект.
  2. Привести &typeid(std::exception) к типу const abi::__class_type_info* (преобразование просто должно сработать).
  3. Вызвав __dynamic_cast, проверить, унаследовано ли thrown_exception от std::exception.
const abi::__class_type_info* exc = dynamic_cast<const abi::__class_type_info*>(&typeid(std::exception));
const abi::__class_type_info* cti = dynamic_cast<abi::__class_type_info*>(tinfo);
if (cti && exc) {
    std::exception* the_exception = reinterpret_cast<std::exception*>(abi::__dynamic_cast(thrown_exception, exc, cti, -1));
    if (the_exception) {
        std::cout << the_exception->what() << std::endl;
    }
}

Осталось получить backtrace. Здесь нет ничего сложного.

Вторая функция (__cxa_rethrow) вызывается из catch-блока и кидает обрабатываемое исключение ещё раз. Так как у функции нет аргументов (совсем нет), то бросаемое исключение придётся получать самостоятельно. Для этого используется функция

extern "C" __cxa_eh_globals *__cxa_get_globals(void);

struct __cxa_eh_globals {
    __cxa_exception* caughtExceptions;
    unsigned int uncaughtExceptions;
};

__cxa_exception — заголовок исключения; непосредственно за ним следует бросаемый объект.

__cxa_eh_globals* g = __cxa_get_globals();
if (g && g->caughtExceptions) {
    void* thrown_exception = reinterpret_cast<uint8_t*>(g->caughtExceptions) + sizeof(struct __cxa_exception);
    std::type_info* tinfo  = g->caughtExceptions->exceptionType;

    // Далее всё аналогично __cxa_throw
}

Всё готово, дело за малым: перехватить вызовы __cxa_throw и __cxa_rethrow. Тут всё просто:

#include <dlfcn.h>

typedef void(*cxa_throw_type)(void* , std::type_info*, void(*)(void*));
typedef void(*cxa_rethrow_type)(void);

cxa_throw_type   orig_cxa_throw   = reinterpret_cast<cxa_throw_type>(dlsym(RTLD_NEXT, "__cxa_throw"));
cxa_rethrow_type orig_cxa_rethrow = reinterpret_cast<cxa_rethrow_type>(dlsym(RTLD_NEXT, "__cxa_rethrow"));

А теперь всё вместе:

#include <typeinfo>
#include <exception>
#include <dlfcn.h>
#include <pthread.h>
#include <cstdio>
#include <cstdlib>
#include <inttypes.h>
#include <execinfo.h>
#include <cxxabi.h> // Определяет типы из namespace abi
#include <cstring>
#include <stdexcept>
#include <unistd.h>

namespace { // Важно: без анонимного пространства имён gcc начинает клинить

typedef uint64_t uint64; // В документации тип зовётся uint64

// Типы/структуры данных из http://sourcery.mentor.com/public/cxx-abi/abi-eh.html
typedef enum {
    _URC_NO_REASON = 0,
    _URC_FOREIGN_EXCEPTION_CAUGHT = 1,
    _URC_FATAL_PHASE2_ERROR = 2,
    _URC_FATAL_PHASE1_ERROR = 3,
    _URC_NORMAL_STOP = 4,
    _URC_END_OF_STACK = 5,
    _URC_HANDLER_FOUND = 6,
    _URC_INSTALL_CONTEXT = 7,
    _URC_CONTINUE_UNWIND = 8
} _Unwind_Reason_Code;

typedef void (*_Unwind_Exception_Cleanup_Fn)(_Unwind_Reason_Code reason, struct _Unwind_Exception* exc);

struct _Unwind_Exception {
    uint64 exception_class;
    _Unwind_Exception_Cleanup_Fn exception_cleanup;
    uint64 private_1;
    uint64 private_2;
};

struct __cxa_exception {
    std::type_info* exceptionType;
    void (*exceptionDestructor)(void*);
    std::unexpected_handler unexpectedHandler;
    std::terminate_handler terminateHandler;
    __cxa_exception* nextException;
    int handlerCount;
    int handlerSwitchValue;
    const char* actionRecord;
    const char* languageSpecificData;
    void* catchTemp;
    void* adjustedPtr;
    _Unwind_Exception unwindHeader;
};

struct __cxa_eh_globals {
    __cxa_exception* caughtExceptions;
    unsigned int uncaughtExceptions;
};

extern "C" __cxa_eh_globals* __cxa_get_globals(void);

// Тип функции __cxa_throw
typedef void(*cxa_throw_type)(void*, std::type_info*, void(*)(void*));
// Тип функции __cxa_rethrow
typedef void(*cxa_rethrow_type)(void);

static cxa_throw_type   orig_cxa_throw   = 0; // Адрес оригинальной функции __cxa_throw
static cxa_rethrow_type orig_cxa_rethrow = 0; // Адрес оригинальной функции __cxa_rethrow

static pthread_mutex_t guard = PTHREAD_MUTEX_INITIALIZER; // Мьютекс на всякий пожарный

// Получение трассы вызовов
// Здесь и далее сознательно используются функции из стандартной библиотеки C, так как они не генерируют исключений
// Исключение в низкоуровневом обработчике исключения - это что-то
static void get_backtrace(void)
{
    static void* buf[128];

    int n = backtrace(buf, 128);
    std::fprintf(stderr, "%s\n", "*** BACKTRACE ***");
    backtrace_symbols_fd(buf, n, STDERR_FILENO);

// Код, приведённый далее, предполагает наличие программ readlink и addr2line
// идея состоит в скармливании адресов, полученных backtrace(3), addr2line(1)
// с целью получения понятного человеку результата
    std::size_t bufsize = 19*n + std::strlen("/usr/bin/addr2line -pifCa -e `/bin/readlink /proc/XXXXX/exe` 1>&2") + 1;
    char* space = reinterpret_cast<char*>(std::calloc(bufsize, 1));
    if (space) {
        char* orig = space;
        int c = std::sprintf(space, "/usr/bin/addr2line -pifCa -e `/bin/readlink /proc/%d/exe` ", getpid());
        space += c;
        for (int i=0; i<n; ++i) {
            c = std::sprintf(space, "%p ", buf[i]);
            space += c;
        }

        std::fprintf(stderr, "%s\n", "\n*** DECODED BACKTRACE ***");
        std::sprintf(space, "%s", "1>&2");

        std::fprintf(stderr, "%s\n", orig);
        if (std::system(orig)) {} // Чтобы не ругался gcc
        std::free(orig);
    }
}

// Обработка исключения, общая для __cxz_throw и __cxa_rethrow
static void handle_exception(void* thrown_exception, std::type_info* tinfo, bool rethrown)
{
    char* demangled = abi:: __cxa_demangle(tinfo->name(), 0, 0, 0);
    std::fprintf(stderr, "%s exception of type %s\n", (rethrown ? "Rethrown" : "Thrown"), (demangled ? demangled : tinfo->name()));
    if (demangled) {
        std::free(demangled);
    }

    const abi::__class_type_info* exc = dynamic_cast<const abi::__class_type_info*>(&typeid(std::exception));
    const abi::__class_type_info* cti = dynamic_cast<abi::__class_type_info*>(tinfo);

    if (cti && exc) {
        std::exception* the_exception = reinterpret_cast<std::exception*>(abi::__dynamic_cast(thrown_exception, exc, cti, -1));
        if (the_exception) {
            std::fprintf(stderr, "what(): %s\n", the_exception->what());
        }
    }

    get_backtrace();
    std::fprintf(stderr, "\n\n");
}

extern "C" void __cxa_throw(void* thrown_exception, std::type_info* tinfo, void (*dest)(void*))
{
    pthread_mutex_lock(&guard);
    handle_exception(thrown_exception, tinfo, false);
    pthread_mutex_unlock(&guard);
   
    if (orig_cxa_throw) {
        orig_cxa_throw(thrown_exception, tinfo, dest);
    }
    else {
        std::terminate();
    }
}

extern "C" void __cxa_rethrow(void)
{
    pthread_mutex_lock(&guard);
    __cxa_eh_globals* g = __cxa_get_globals();
    if (g && g->caughtExceptions) {
        void* thrown_exception = reinterpret_cast<uint8_t*>(g->caughtExceptions) + sizeof(struct __cxa_exception);
        handle_exception(thrown_exception, g->caughtExceptions->exceptionType, true);
    }

    pthread_mutex_unlock(&guard);

    if (orig_cxa_rethrow) {
        orig_cxa_rethrow();
    }
    else {
        std::terminate();
    }
}

// Инициализация переменных. Можно сделать это и в обработчике, но так безопаснее
static void initialize(void)
{
    orig_cxa_throw   = reinterpret_cast<cxa_throw_type>(dlsym(RTLD_NEXT, "__cxa_throw"));
    orig_cxa_rethrow = reinterpret_cast<cxa_rethrow_type>(dlsym(RTLD_NEXT, "__cxa_rethrow"));
}

}

int main(int, char**)
{
    initialize();

    try {
        try {
            throw std::runtime_error("123");
        }
        catch (const std::exception& e) {
            std::printf("e.what(): %s\n", e.what());
            throw;
        }
    }
    catch (const std::exception& d) {
        std::printf("d.what(): %s\n", d.what());
    }

    try {
        throw 1;
    }
    catch (int x) {
        std::printf("%d\n", x);
    }
   
    return 0;
}

Пример работы (у меня в оригинале кода нет комментариев, так что номера строк будут отличаться):

$ g++ test.cpp -O2 -g -o test -ldl
$ ./test
Thrown exception of type std::runtime_error
what(): 123
*** BACKTRACE ***
./test[0x401127]
./test(__cxa_throw+0x33)[0x401303]
./test[0x40141f]
/lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xed)[0x7f3c05c2576d]
./test[0x400fa9]

*** DECODED BACKTRACE ***
/usr/bin/addr2line -pifCa -e `/bin/readlink /proc/4387/exe` 0x401127 0x401303 0x40141f 0x7f3c05c2576d 0x400fa9 1>&2
0x0000000000401127: fprintf at /usr/include/x86_64-linux-gnu/bits/stdio2.h:99
 (inlined by) get_backtrace at /home/vladimir/test/test.cpp:73
 (inlined by) handle_exception at /home/vladimir/test/test.cpp:114
0x0000000000401303: __cxa_throw at /home/vladimir/test/test.cpp:122
0x000000000040141f: main at /home/vladimir/test/test.cpp:167
0x00007f3c05c2576d: ??
??:0
0x0000000000400fa9: _start at ??:0


e.what(): 123
Rethrown exception of type std::runtime_error
what(): 123
*** BACKTRACE ***
./test[0x401127]
./test(__cxa_rethrow+0x31)[0x401371]
./test[0x4014de]
/lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xed)[0x7f3c05c2576d]
./test[0x400fa9]

*** DECODED BACKTRACE ***
/usr/bin/addr2line -pifCa -e `/bin/readlink /proc/4387/exe` 0x401127 0x401371 0x4014de 0x7f3c05c2576d 0x400fa9 1>&2
0x0000000000401127: fprintf at /usr/include/x86_64-linux-gnu/bits/stdio2.h:99
 (inlined by) get_backtrace at /home/vladimir/test/test.cpp:73
 (inlined by) handle_exception at /home/vladimir/test/test.cpp:114
0x0000000000401371: __cxa_rethrow at /home/vladimir/test/test.cpp:141
0x00000000004014de: main at /home/vladimir/test/test.cpp:179
0x00007f3c05c2576d: ??
??:0
0x0000000000400fa9: _start at ??:0


d.what(): 123
Thrown exception of type int
*** BACKTRACE ***
./test[0x401127]
./test(__cxa_throw+0x33)[0x401303]
./test[0x4014b7]
/lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xed)[0x7f3c05c2576d]
./test[0x400fa9]

*** DECODED BACKTRACE ***
/usr/bin/addr2line -pifCa -e `/bin/readlink /proc/4387/exe` 0x401127 0x401303 0x4014b7 0x7f3c05c2576d 0x400fa9 1>&2
0x0000000000401127: fprintf at /usr/include/x86_64-linux-gnu/bits/stdio2.h:99
 (inlined by) get_backtrace at /home/vladimir/test/test.cpp:73
 (inlined by) handle_exception at /home/vladimir/test/test.cpp:114
0x0000000000401303: __cxa_throw at /home/vladimir/test/test.cpp:122
0x00000000004014b7: main at /home/vladimir/test/test.cpp:167
0x00007f3c05c2576d: ??
??:0
0x0000000000400fa9: _start at ??:0


1

Для proof of concept очень даже неплохо.

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

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

]]> http://blog.sjinks.pro/c-cpp/969-track-uncaught-exceptions/feed/ 1 Совмещение различных конфигураций сборок при использовании qmake http://blog.sjinks.pro/c-cpp/qt/967-qmake-combine-different-build-types/ http://blog.sjinks.pro/c-cpp/qt/967-qmake-combine-different-build-types/#comments Sat, 28 Apr 2012 23:45:14 +0000 Wandering Soul http://blog.sjinks.pro/?p=967 © 2012 Ars Longa, Vita Brevis. Все права защищены. Перепубликация материалов без разрешения автора запрещена.

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

]]> Недокументированные костыли

В продолжение темы одновременной сборки взаимно несовместимых конфигураций.

В предыдущей записи было показано, что qmake позволяет собирать одновременно взаимно несовместимые конфигурации, как-то: отладочная и релиз-версия приложения, статическая и динамическая версия библиотеки.

Тем не менее, без лишних телодвижений совместить несколько конфигураций сборок (например, отладочная и релиз-версия статической и динамической библиотеки) проблематично.

В частности, если задать такую конфигурацию:

CONFIG += static_and_shared debug_and_release build_all

qmake сгенерирует только каталоги debug и release, хотя и создаст все пять Makefile:

$ ls -1
debug
Makefile
Makefile.SharedDebug
Makefile.SharedRelease
Makefile.StaticDebug
Makefile.StaticRelease
release

Выполнив make, видим, что с таким подходом результат может быть весьма непредсказуемым: в моём случае сначала собиралась цель shared-release, затем shared-debug, затем из объектных файлов, собранных для цели shared-release, собиралась статическая библиотека для цели static-release; аналогично со static-debug.

Плохо это по крайней мере по двум причинам:

  1. Ломается параллельная сборка: при сборке библиотеки может случиться ситуация, когда смешиваются по-разному скомпилированные объектные файлы (например, с и без PIC); в лучшем случае получим предупреждение от компоновщика (что-нибудь загадочное вида error: /tmp/ccdxxjfh.ltrans1.ltrans.o: requires dynamic R_X86_64_PC32 reloc against 'vtable for ClassName' which may overflow at runtime; recompile with -fPIC), в худшем — столкнёмся с весьма интересными ошибками
  2. Однозадачная сборка зависит от порядка сборки целей: например, если собирать сначала статическую цель, затем — динамическую, и если при этом статическая библиотека явно не экспортирует функции (например, собирается с -fvisibility=hidden), то динамическая цель, собранная из файлов для статической цели, может оказаться неработоспособной.

Причина, по которой это происходит, лежит в недрах qmake: всё дело в том, что сборка несовместимых конфигураций является неким костылём. Костыльность эта заключается именно в обработке целей:

  • начальная конфигурация: static_and_shared debug_and_release build_all
  • изначально имеем пустую переменную OBJECTS_DIR
  • qmake начинает с релизной сборки из debug_and_release
  • обработка первой цели (Release) поместит в OBJECTS_DIR значение release
  • qmake обрабатывает «вложенную» сборку: shared из static_and_shared
  • костыль: qmake предполагает, что предыдущей сборки либо не было (OBJECTS_DIR и компания пусты — в этом случае каталог для временных файлов будет совпадать с именем сборки, в нашем случае это shared), либо конфигурация предыдущей сборки была «антиподом» текущей (то есть static в данном случае) — тогда в OBJECTS_DIR и сопуствующих переменных static заменяется на shared. Но проблема тут в том, что предыдущая конфигурация была release, а не static; как следствие, замена не получится, каталогом для временных файлов останется release
  • затем обрабатывается конфигурация debug; в OBJECTS_DIR release успешно заменяется на debug
  • затем обрабатывается подконфигурация shared; OBJECTS_DIR остаётся без изменений
  • краткий итог: конфигурация release/shared собрана в release, debug/shared — в debug
  • затем обрабатывается конфигурация static; OBJECTS_DIR опять остаётся без изменений (debug)
  • обрабатывается подконфигурация release; в OBJECTS_DIR debug успешно заменяется на release; в результате static/release будет собираться в release, где собиралась конфигурация release/shared
  • совершенно аналогично static/debug будет собираться в debug, где собиралась конфигурация debug/shared

Временные файлы (в зависимости от их типа) помещаются в каталоги, указанные переменными OBJECTS_DIR, MOC_DIR и RCC_DIR.

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

У меня получилось так:

CONFIG += static_and_shared debug_and_release build_all

debug: TARGET = $$join(TARGET,,,_debug)

StaticDebug:   OBJECTS_DIR = StaticDebug
SharedDebug:   OBJECTS_DIR = SharedDebug
StaticRelease: OBJECTS_DIR = StaticRelease
SharedRelease: OBJECTS_DIR = SharedRelease

MOC_DIR = $$OBJECTS_DIR
RCC_DIR = $$OBJECTS_DIR

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

В общем, happy hackin’!

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

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

]]> http://blog.sjinks.pro/c-cpp/qt/967-qmake-combine-different-build-types/feed/ 0 Одновременная сборка статической и динамической библиотеки с qmake http://blog.sjinks.pro/c-cpp/qt/966-qmake-static-shared-library/ http://blog.sjinks.pro/c-cpp/qt/966-qmake-static-shared-library/#comments Sun, 22 Apr 2012 12:46:07 +0000 Wandering Soul http://blog.sjinks.pro/?p=966 © 2012 Ars Longa, Vita Brevis. Все права защищены. Перепубликация материалов без разрешения автора запрещена.

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

]]> Недокументированные возможности

Задача: заставить qmake генерировать статическую и динамическую библиотеку при использовании шаблона сборки lib.

Решение: хотя считается, что без костылей такая возможность не реализуется, на самом деле это не так: поддержка одновременной сборки статической и динамической версии библиотеки присутствует по крайней мере со времён 4.5.

Всё дело в волшебных prf-файлах. Цитируя официальную документацию,

qmake lets you create your own features that can be included in project files by adding their names to the list of values specified by the CONFIG variable. Features are collections of custom functions and definitions in .prf files that can reside in one of many standard directories.

Если посмотреть каталог mkspec/features в Qt (например, в Ubuntu/Debian это /usr/share/qt4/mkspecs/features/), можно увидеть файл static_and_shared.prf, отвечающий за одновременную сборку статической и динамической версии библиотек.

Использовать это можно так:

TEMPLATE  = lib
CONFIG   += static_and_shared create_prl build_all

TEMPLATE = lib задаёт шаблон сборки (библиотека), static_and_shared задаёт режим сборки, create_prl (используется при сборке статической библиотеки) включает режим отслеживания зависимостей библиотеки, build_all указывает, что собирать нужно обе версии.

Из параметров CONFIG недокументированным является только static_and_shared.

Задать различные опции для статической и динамической сборки можно через функцию CONFIG:

build_pass: CONFIG(static, static|shared) {
# Опции для статической библиотеки
}

build_pass: CONFIG(shared, static|shared) {
# Опции для динамической библиотеки
}

На закуску еще две полезных опции для использования в CONFIG для /UNIX:

  1. hide_symbols: установка видимости символов по умолчанию в hidden. Для чего нужно, читаем здесь.
  2. bsymbolic_functions: привязка ссылок на глобальные функции к определениям этих функций в самой библиотеке (что не позволит привязывать ссылки из библиотеки на свои функции к функциям, экспортируемым из другой библиотеки)

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

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

]]> http://blog.sjinks.pro/c-cpp/qt/966-qmake-static-shared-library/feed/ 1 Отслеживание источника исключения в Qt http://blog.sjinks.pro/c-cpp/qt/964-exception-source-qt/ http://blog.sjinks.pro/c-cpp/qt/964-exception-source-qt/#comments Fri, 13 Apr 2012 21:05:31 +0000 Wandering Soul http://blog.sjinks.pro/?p=964 © 2012 Ars Longa, Vita Brevis. Все права защищены. Перепубликация материалов без разрешения автора запрещена.

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

]]> Получение трассы вызовов к источнику исключений в

Если приложение (или сама библиотека Qt) бросает исключение, которое не обрабатывается приложением, исключение попадает в цикл обработки событий Qt (известный как event loop), который выводит сообщение наподобие:

Qt has caught an exception thrown from an event handler. Throwing
exceptions from an event handler is not supported in Qt. You must
reimplement QApplication::notify() and catch all exceptions there.

При использовании libstdc++ может быть выдана дополнительная диагностика:

terminate called after throwing an instance of ‘std::bad_alloc’
what(): std::bad_alloc

Получение стека вызовов из обработчика не пойманных исключений (std::set_terminate) здесь не поможет: трасса приведёт к тому месту, откуда исключение было брошено повторно — то есть в цикл обработки событий Qt.

В случае использования проблему можно решить, поставив в отладчике точку прерывания на функцию __cxa_throw.

Например, в случае с gdb:

$ gdb buggy_app
GNU gdb (Ubuntu/Linaro 7.4-2012.02-0ubuntu2) 7.4-2012.02
Copyright (C) 2012 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
and "show warranty" for details.
This GDB was configured as "x86_64-linux-gnu".
For bug reporting instructions, please see:
<http://bugs.launchpad.net/gdb-linaro/>...
Reading symbols from /path/to/buggy_app...done.
(gdb) start
Temporary breakpoint 1 at 0x405f6d: file main.cpp, line 75.
Starting program: /path/to/buggy_app
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".

Temporary breakpoint 1, main (argc=3, argv=0x7fffffffe008) at main.cpp:75
75              QCoreApplication a(argc, argv);
(gdb) b __cxa_throw
Breakpoint 2 at 0x7ffff7154910
(gdb) c
Continuing.

Breakpoint 2, 0x00007ffff7154910 in __cxa_throw () from /usr/lib/x86_64-linux-gnu/libstdc++.so.6
(gdb) bt
#0  0x00007ffff7154910 in __cxa_throw () from /usr/lib/x86_64-linux-gnu/libstdc++.so.6
#1  0x00007ffff762d102 in qBadAlloc () at global/qglobal.cpp:1994
#2  0x00007ffff7fe6e7e in DnsRequestQueuePrivate::_q_resultsReady (this=0x43af90, r=..., id=11771, code=0, ctx=...) at dnsrequestqueue.cpp:83
#3  0x00007ffff7fe7629 in DnsRequestQueue::qt_static_metacall (_o=0x7fffffffded8, _c=QMetaObject::InvokeMetaMethod, _id=1, _a=0x43d130) at debug/moc_dnsrequestqueue.cpp:53
#4  0x00007ffff7750446 in QObject::event (this=0x7fffffffded8, e=<optimized out>) at kernel/qobject.cpp:1195
#5  0x00007ffff7736e9c in QCoreApplication::notifyInternal (this=0x7fffffffdf00, receiver=0x7fffffffded8, event=0x43d310) at kernel/qcoreapplication.cpp:876
...

Для экстремалов есть такое решение: Hijacking throw

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

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

]]> http://blog.sjinks.pro/c-cpp/qt/964-exception-source-qt/feed/ 1 Undefined reference на специализацию шаблона статического поля http://blog.sjinks.pro/c-cpp/962-undefined-reference-to-static-field-template-initialization/ http://blog.sjinks.pro/c-cpp/962-undefined-reference-to-static-field-template-initialization/#comments Sat, 31 Mar 2012 20:24:53 +0000 Wandering Soul http://blog.sjinks.pro/?p=962 © 2012 Ars Longa, Vita Brevis. Все права защищены. Перепубликация материалов без разрешения автора запрещена.

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

]]> временами весьма капризен

Столкнулся на работе с такой проблемой при написании расширения для QtScript: код вида

template<typename T>
class EnumWrapper {
/* ... */

protected:
    static QMap<int, QString> m_enum_map;
    static QString m_class;
/* ... */
};

template<> QMap<int, QString> EnumWrapper<QTextStream::RealNumberNotation>::m_enum_map;
template<> QString EnumWrapper<QTextStream::RealNumberNotation>::m_class(QLatin1String("QTextStream"));

class QTextStream_RealNumberNotation : public EnumWrapper<QTextStream::RealNumberNotation> {
public:
    QTextStream_RealNumberNotation(void)
    {
        EnumWrapper<QTextStream::RealNumberNotation>::m_enum_map.insert(int(QTextStream::SmartNotation), QLatin1String("SmartNotation"));
        EnumWrapper<QTextStream::RealNumberNotation>::m_enum_map.insert(int(QTextStream::FixedNotation), QLatin1String("FixedNotation"));
        EnumWrapper<QTextStream::RealNumberNotation>::m_enum_map.insert(int(QTextStream::ScientificNotation), QLatin1String("ScientificNotation"));
    }
};

/* ... */

QTextStream_RealNumberNotation c;

делает полученную библиотеку незагружаемой.

Методом проб и ошибок было установлено, что всему виной такая декларация:

template<> QMap<int, QString> EnumWrapper<QTextStream::RealNumberNotation>::m_enum_map;

Чтобы лучше понять суть проблемы, набросал небольшой test case, который не использует сторонних библиотек (мало ли, вдруг виноват):

#include <map>
#include <utility>

template<typename T>
class Test {
public:
    Test(void)
    {
        m_map.insert(std::make_pair(0, 0));
    }

    static std::map<int, int> m_map;
};

template<> std::map<int, int> Test<char>::m_map;

int main(int, char**)
{
    Test<char> t;
    return 0;
}

И вот оно, gcc громко ругается:

$ g++ test.cpp -o test
/tmp/ccyD9dfl.o:test.cpp:function Test<char>::Test(): error: undefined reference to 'Test<char>::m_map'
collect2: ld returned 1 exit status

Компоновщик почему-то в упор отказывается замечать декларацию

template<> std::map<int, int> Test<char>::m_map;

В VC9 такое не проявляется.

На решение натолкнула следующая за QMap декларация:

template<> QString EnumWrapper<QTextStream::RealNumberNotation>::m_class(QLatin1String("QTextStream"));

На неё компоновщик не ругается. А вся разница — в явном вызове конструктора. Поэтому, если сделать как-то так:

template<> std::map<int, int> Test<char>::m_map = std::map<int, int>();

// Для исходного случая:

template<> QMap<int, QString> EnumWrapper<QTextStream::RealNumberNotation>::m_enum_map = QMap<int, QString>();

то компоновщик перестаёт ругаться.

Шаблонная магия и костылестроение.

Может, кому-то пригодится.

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

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

]]> http://blog.sjinks.pro/c-cpp/962-undefined-reference-to-static-field-template-initialization/feed/ 2 Qt, libfcgi и многопоточность http://blog.sjinks.pro/c-cpp/qt/956-qt-libfcgi-multithreading/ http://blog.sjinks.pro/c-cpp/qt/956-qt-libfcgi-multithreading/#comments Sun, 08 Jan 2012 17:31:00 +0000 Vladimir http://blog.sjinks.pro/?p=956 © 2012 Ars Longa, Vita Brevis. Все права защищены. Перепубликация материалов без разрешения автора запрещена.

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

]]> Предотвращение блокирования событий при использовании libfcgi в многопоточном режиме

Для создания приложений на есть библиотека libfcgi. Не буду вдаваться в дискуссию, зачем нужны приложения FastCGI на C/C++/подставить нужный язык, когда Python/PHP/Perl/подставить нужное гораздо удобнее. Отмечу лишь, что по работе понадобилось написать FastCGI-приложение на (в основном из-за наличия нескольких высокопроизводительных библиотек, написанных на , но не суть).

Строго говоря, libfcgi, хотя и является официальной библиотекой от создателей протокола, не лучший вариант для поддержки FastCGI — API, предоставляемое библиотекой, сильно ограничено (в плане функциональности) и недостаточно гибко.

Грубо говоря, приложение, использующее libfcgi, может работать в двух режимах:

  1. Последовательная обработка запросов: приложение получило запрос, обработало его, отправило результат, получило следующий запрос. Схема хороша, если обработка запроса тривиальна и/или не занимает много времени. Скорее всего, под большой нагрузкой масштабируется плохо, ибо чем длиннее очередь запросов, тем дольши придётся ждать клиенту.
  2. Многопоточная обработка запросов: приложение создаёт определённое количество потоков, каждый из которых будет обрабатывать свой запрос. При средних нагрузках эта схема работает лучше (если один поток занят, свободный поток займётся выполнением запроса). Но в предельном случае (когда все заняты) имеем те же проблемы, что и в первом варианте. Схему можно немного изменить, создавая по мере необходимости, но всё равно плодить до бесконечности нельзя.

Использование потоков не всегда уместно/хорошо: многопоточные программы, как правило, сложнее для разработки и отладки; кроме того, потоки потребляют системные ресурсы (например, память для стека) и при большом количестве потоков эти издержки могут быть существенными (например, для /IA-32 размер стека для потока по умолчанию составляет 2 мегабайта).

К сожалению, при использовании libfcgi отказаться от потоков очень трудно — дело в том, что библиотека использует блокирующие операции при работе с сокетами.

В общем случае алгоритм работы с libfcgi следующий:

/* Инициализация */
FCGX_Init();
int socket = FCGX_OpenSocket(":9001", 256);

/* ... */

// Собственно работа
while (true) {
    FCGX_Request* req = new FCGX_Request;
    FCGX_InitRequest(req, socket, 0);

    int rc = FCGX_Accept_r(req);
    if (rc >= 0) {
        /* Здесь создаём и запускаем поток, отвечающий за обработку запроса */
    }
}

В случае с Qt и использованием рабочего цикла внутри основной программы имеется неприятный подводный камень: из-за того, что FCGX_Accept_r() использует блокирующие вызовы при работе с сокетом, основная программа может очень долго не увидеть сообщения, посылаемые, например, потоком.

Поэтому перед вызовом FCGX_Accept_r() имеет смысл проверять, имеются ли запросы на соединение.
Решение в лоб:

#include <QtCore/QCoreApplication>
#include <sys/select.h>

/* ... */

int rc;
do {
    QCoreApplication::processEvents();
    struct timeval tv = { 0, 500 };
    fd_set r;
    FD_ZERO(&r);
    FD_SET(socket, &r);

    rc = ::select(socket+1, &r, 0, 0, &tv);
} while (!rc);

FCGX_Request* req = new FCGX_Request;
FCGX_InitRequest(req, socket, 0);
int sock = FCGX_Accept_r(req);
/* ... */

Но более корректно будет использовать QSocketNotifier:

// core.h
#include <QtCore/QObject>

class QSocketNotifier;

class Core : public QObject {
    Q_OBJECT
public:
    explicit Core(QObject *parent = 0);
    void run(void);

private:
    QSocketNotifier* m_notifier;

private slots:
    void connectionPending(int socket);
};

// core.cpp

Core::Core(QObject *parent) : QObject(parent), m_notifier(0)
{
    FCGX_Init();
    int sock = FCGX_OpenSocket(":9001", 256);
    this->m_notifier = new QSocketNotifier(sock, QSocketNotifier::Read);
    QObject::connect(this->m_notifier, SIGNAL(activated(int)), this, SLOT(connectionPending(int)));
}

void Core::connectionPending(int socket)
{
    QSocketNotifier* notifier = qobject_cast<QSocketNotifier*>(this->sender());
    Q_CHECK_PTR(notifier);

    notifier->setEnabled(false);

    FCGX_Request* req = new FCGX_Request;
    FCGX_InitRequest(req, socket, 0);
    int s = FCGX_Accept_r(req);
    if (s >= 0) {
        /* Здесь создаём и запускаем поток */
    }

    notifier->setEnabled(true);
}

В качестве альтернативы созданию потоков можно предложить использовать очередь запросов.

#include <QtCore/QMutex>
#include <QtCore/QMutexLocker>
#include <QtCore/QQueue>
#include <QtCore/QWaitCondition>

class Queue {
public:
    void addToQueue(FCGX_Request* r, bool broadcast = false)
    {
        QMutexLocker locker(&this->mx);
        this->queue.enqueue(r);
        if (broadcast) {
            this->cv.wakeAll();
        }
        else {
            this->cv.wakeOne();
        }
    }

    FCGX_Request* getFromQueue(void)
    {
        this->mx.lock();
        while (this->queue.isEmpty()) {
            this->cv.wait(&this->mx);
        }

        FCGX_Request* result = this->queue.dequeue();
        this->mx.unlock();
        return result;
    }
private:
    QMutex mx;
    QWaitCondition cv;
    QQueue<FCGX_Request*> queue;
};

Но это уже совсем другая история.

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

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

]]> http://blog.sjinks.pro/c-cpp/qt/956-qt-libfcgi-multithreading/feed/ 3 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/ 5 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