Какой лучший способ запустить дорогостоящую инициализацию?

У меня есть синглтон, который стоит дорого инициализировать:

struct X {...};

const X&
get_X()
{
    static const X x = init_X();
    return x;
}

В первый раз, когда вызывается get_X(), для инициализации функции-local static может потребоваться сотни миллисекунд. Но после этого все, что мне нужно сделать с X, относительно быстро:

get_X().find_something_for_me();  // expensive if this is the first call
get_X().find_something_for_me();  // now fast

Как я могу свести к минимуму большую задержку при первом вызове get_X()? У меня много ядер...

Ответы

Ответ 1

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

#include <thread>

int
main()
{
    std::thread(get_X).detach();
    // continue with other initialization...
}

Когда какая-то задача стоит так дорого, как несколько сотен миллисекунд (или больше), накладные расходы на отключение потока для борьбы с ним - это уровень шума. И если вы работаете на многоядерном оборудовании (что не в наши дни?), То это четкий выигрыш в производительности, если ваше приложение действительно ничего не нуждается в этом синглтоне, пока не завершится первоначальный вызов get_X.

Примечания/Вопросы:

  • Почему detach thread? Почему бы не join?

    Если вы решите join этот thread, это означает, что вам просто нужно подождать, пока он закончит, а почему бы и нет. Когда он закончит, detach очистится после себя. Вам даже не нужно сохранять дескриптор thread. Временный std::thread разрушает, но поток ОС продолжает работать, завершая get_X.

    Когда стандартизован thread, были точки зрения, что detach ed thread были не только бесполезны, но и опасны. Но вот совершенно безопасный и вполне мотивирующий прецедент для detach ed thread s.

  • Что делать, если мое приложение вызывает get_X() до того, как detach ed thread завершит первый вызов get_X()?

    Появляется удар производительности, но не попадание правильности. Ваше приложение будет блокироваться в этой строке в get_X():

    static const X x = init_X();

    пока detach ed thread не закончит выполнение. Таким образом, нет расы данных.

  • Что делать, если мое приложение заканчивается до завершения detach ed thread?

    Если ваше приложение заканчивается на этапе инициализации, что-то, очевидно, катастрофически ошибочно. Если get_X касается чего-то, что уже разрушено цепочкой at_exit (которая выполняется после main), произойдут плохие вещи. Тем не менее, вы уже находитесь в состоянии панического отключения... еще одна аварийная ситуация вряд ли ухудшит вашу панику. Ты уже мертв. Otoh, если ваша инициализация - это что-то, что занимает от нескольких минут до нескольких часов, вам, вероятно, нужно улучшить общение о завершении инициализации и более грациозных процедурах закрытия. В этом случае вам необходимо осуществить совместное аннулирование в ваших потоках, отключенных или нет (то, что комитет std отказался предоставить вам).

  • Что делать, если первый вызов get_X() вызывает исключение?

    В этом случае второй вызов get_X() имеет возможность инициализировать функцию local static, предполагая, что вы не оставите исключение неотображаемым и разрешите ему завершить работу вашей программы. Он может слишком бросаться, или может преуспеть в инициализации (это зависит от вашего кода). В любом случае вызовы get_X() будут продолжать пытаться инициализировать, ожидая выполнения инициализации, пока кому-то не удастся сделать это, не выбрасывая исключение. И это все правда, поступают ли вызовы из разных потоков или нет.

В заключение

std::thread(get_X).detach();

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

Единственным недостатком является то, что вы инициализируете данные в get_X(), нужен ли вам это или нет. Поэтому убедитесь, что вам это понадобится, прежде чем использовать эту технику.

[Сноска] Для тех, кто использует Visual Studio, это хорошая мотивация для перехода на VS-2015. До этой версии VS не реализует потокобезопасную функцию - локальную статику.

Ответ 2

Если вы не возражаете против задержки при запуске приложения, вы можете сделать x как статический частный член класса, например этот

#include <iostream>

class X {
public:
    static X const& get_x();
private:
    static X const x;

    X()
    {
        std::cout << "X init" << std::endl;
    }
};

int main()
{
    std::cout << "Enter main" << std::endl;
    X::get_x();
    return 0;
}

X const X::x;

X const& X::get_x()
{
    return X::x;
}