При разработке любой программы сложнее чем простейшая утилита командной строки встает вопрос об организации подсистем и их взаимодействии. Он включает в себя декомпозицию функционала программы на подсистемы и организацию способа их взаимодействия. Именно об организации взаимодействия подсистем, а так же управления их созданием и удалением будет идти речь в статье.
Пример
Необходимо написать программу, которая захватывает изображение с веб-камеры обрабатывает его и отображает результат на экран в реальном времени. После декомпозиции выявлено 3 сущности:
- Подсистема захвата видеопотока.
- Подсистема отображения.
- Подсистемы обработки видеопотока.
class processor
{
public:
static processor & singleton();
void * process(void *data);
private:
processor() {};
processor(const processor&) {};
};
class capturer
{
public:
capturer(const std::string &file_name);
void * frame();
};
class render
{
public:
render(const std::string &name, int width, int height);
void start();
void stop();
void render_frame(void *frame);
};
Необходимо организовать взаимодействие, создание и удаление этих подсистем. При этом можно выделить следующие требования к способу организации:
- Читаемость кода (до 90% времени программисты тратят на чтение чужого кода).
- Скорость работы программы (способ организации не должен накладывать дополнительные расходы).
- Гибкость (возможность добавлять различные подсистемы, независимо от их интерфейса).
- Простое и явное управление временем жизни объектов подсистем.
Способы решения
За время своей работы профессиональным программистом я успел поработать в нескольких компаниях, известных и неизвестных. Далее я приведу способы решения описываемой в данной статье проблемы, которые встречал на практике.
Синглтоны
Работа со всеми подсистемами в программе осуществляется при помощи синглтонов. Достаточно хорошее решение, но имеет один большой недостаток – это управление временем жизни объектов. И если с созданием синглтонов еще можно сделать воркэраунд, вызывая их явно в нужно порядке, то с удалением всегда появляются проблемы. Нередко проблема удаления объектов-синглтонов решается при помощи черной магии вроде синглтона типа феникс.
Божественный объект
Все подсистемы включаются как поля одного класса, который при создании их всех инициализирует в нужном порядке, а потом и разрушает. Как правило у такого божественного объекта в конструкторе предаются параметры для инициализации всех подсистем, он раздувается до космических размеров. Так же возникает проблема организации доступа одной подсистемы к другой, т.к. при этом мы должны явно передавать в каждую подсистему указатель на божественный объект.
Сигналы
Каждая подсистема реализует некий механизм обработки событий/сигналов из общей для всего приложения очереди. Идеологически очень хорошее решение, но на практике приводит к необходимости писать много ненужного кода, реализации ненужных интерфейсов и т.д. К тому же немного страдает скорость выполнения программы.
Мой способ организация подсистем
Этот способ является результатом последовательного развития моих мыслей и поиска оптимального решения на протяжении последних лет. Итак задача ясна, представляю сразу готовое решение с комментариями.
Выделяется 3 типа подсистем:
- Управляемые(managed). Созданием и удалением этих подсистем мы занимаемся сами. К тому же они обязаны реализовывать некоторый заданный интерфейс, например, методы start() и stop(). Так же эти подсистемы имеют доступ к другим подсистемам в программе.
- Неуправляемые(unmanaged). Создаем и удаляем их мы сами, но не накладываем никаких ограничений на интерфейс.
- Внешние(external). Не управляем созданием и удалением. Нет ограничений на интерфейс.
Обращение ко всем подсистемам универсально и осуществляется через менеджер подсистем(master).
Код
Интерфейс управлемых подсистем
// subsystem.hpp
class master_t;
class subsystem_t
{
friend class master_t;
public:
virtual void start() {}
virtual void stop() {}
virtual inline ~subsystem_t() = 0;
inline master_t & master();
private:
master_t *m_master;
};
// Implementation
inline subsystem_t::~subsystem_t()
{
}
inline master_t & subsystem_t::master()
{
return *m_master;
}
Менеджер подсистем
// master.hpp
# include "subsystem.hpp"
# include "noncopyable.hpp"
# include <vector>
# include <cassert>
class master_t : private noncopyable_t
{
public:
template <typename SubsystemType, typename... Args>
inline void add_managed_subsystem(Args ...args);
template <typename SubsystemType, typename... Args>
inline void add_unmanaged_subsystem(Args ...args);
template <typename SubsystemType>
inline void add_external_subsystem(SubsystemType *raw_pointer);
template <typename SubsystemType>
inline SubsystemType & subsystem();
inline void start();
inline void stop();
inline ~master_t();
private:
std::vector<subsystem_t *> m_subsystems;
};
// Implementation
inline void master_t::start()
{
for (auto &subsystem : m_subsystems)
{
subsystem->start();
}
}
inline void master_t::stop()
{
for (auto &subsystem : m_subsystems)
{
subsystem->stop();
}
}
inline master_t::~master_t()
{
for (auto &subsystem : m_subsystems)
{
delete subsystem;
}
}
namespace internal
{
template <typename SubsystemType>
inline SubsystemType ** subsystem_instance()
{
static SubsystemType *instance = 0;
return &instance;
}
template <typename SubsystemType>
struct unmanaged_holder_t : public subsystem_t
{
template <typename... Args>
inline unmanaged_holder_t(Args ...args) : holder(args...) {}
SubsystemType holder;
};
}
template <typename SubsystemType, typename... Args>
inline void master_t::add_managed_subsystem(Args ...args)
{
SubsystemType **instance = internal::subsystem_instance<SubsystemType>();
assert(*instance == 0);
*instance = new SubsystemType(args...);
static_cast<subsystem_t *>(*instance)->m_master = this;
m_subsystems.push_back(*instance);
}
template <typename SubsystemType, typename... Args>
inline void master_t::add_unmanaged_subsystem(Args ...args)
{
SubsystemType **instance = internal::subsystem_instance<SubsystemType>();
assert(*instance == 0);
internal::unmanaged_holder_t<SubsystemType> *unmanaged_holder = new internal::unmanaged_holder_t<SubsystemType>(args...);
*instance = &(unmanaged_holder->holder);
m_subsystems.push_back(unmanaged_holder);
}
template <typename SubsystemType>
inline void master_t::add_external_subsystem(SubsystemType *raw_pointer)
{
SubsystemType **instance = internal::subsystem_instance<SubsystemType>();
assert(*instance == 0);
*instance = raw_pointer;
}
template <typename SubsystemType>
inline SubsystemType & master_t::subsystem()
{
SubsystemType **instance = internal::subsystem_instance<SubsystemType>();
assert(*instance != 0);
return **instance;
}
Пример использования
// main.cpp
#include "subsystem.hpp"
#include "master.hpp"
#include <iostream>
#include <string>
// external
class processor
{
public:
static processor & singleton()
{
static processor instance;
return instance;
}
void * process(void *data)
{
std::cout << "processor: process" << std::endl;
return data;
}
private:
processor() {};
processor(const processor&) {};
};
// unmanaged
class capturer
{
public:
capturer(const std::string &file_name)
: m_file_name(file_name)
{}
void * frame()
{
return nullptr;
}
private:
const std::string m_file_name;
};
// managed
class render : public subsystem_t
{
public:
render(const std::string &name, int width, int height)
: m_name(name)
, m_width(width)
, m_height(height)
{
}
virtual void start()
{
std::cout << "render start" << std::endl;
}
virtual void stop()
{
std::cout << "render stop" << std::endl;
}
void render_frame(void *frame)
{
void *processed = master().subsystem<processor>().process(frame);
std::cout << "Render[" << m_name << "]: render_frame " << processed << std::endl;
}
private:
const std::string m_name;
int m_width;
int m_height;
};
int main()
{
master_t master;
master.add_unmanaged_subsystem<capturer>("test1.avi");
master.add_managed_subsystem<render>("wnd1:", 640, 480);
master.add_external_subsystem<processor>(&processor::singleton());
master.start();
//while (true)
void *frame = master.subsystem<capturer>().frame();
master.subsystem<render>().render_frame(frame);
// }
master.stop();
return 0;
}
Автор: Inkooboo
