Главная
Блог разработчиков phpBB
 
+ 17 предустановленных модов
+ SEO-оптимизация форума
+ авторизация через соц. сети
+ защита от спама

Динамический поиск возможных взаимоблокировок

Anna | 24.06.2014 | нет комментариев

Здравствуйте. Некоторое время назад начал заниматься сопровождением достаточно объемного программного продукта. Правка за правкой и как-то неприметно ко мне подкрались взаимоблокировки. Я стремительно узнал источник задач — это вложенные блокировки. По незнанию основ программного продукта я неявно нарушил порядок вложения блокировок. Но обнаружить вручную источник задач не удалось.

Боржоми пить поздно, причитать насчёт архитектуры безрезультатно. Подключаем тяжелую артиллерию.


Выходит, классическая задача (псевдокод):

object m1;
object m2;

// thread 1
quard<> g1(m1);
....
// ждем освобождения m2 потоком thread 2 
quard<> g2(m2);

// thread 2
quard<> g2(m2);
....
// ждем освобождения m2 потоком thread 1
quard<> g1(m1);

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

Идея.

Пускай класс блокировщик составляет граф последовательности блокировок объектов и когда при следующий вставке будет найдена циклическая ссылка это и будет желанная потенциальная взаимоблокировка.
Пример:
где то в коде потока: guard(m1) –> guard(m2)
где то в коде потока: guard(m2) –> guard(m1)!!! alarm!!! найдена циклическая ссылка.

Реализация

Делать реализацию графов самосильно это тяжко. Я задействовал «boost/graph».
Для учёта вероятности блокировки в потоках модулей DLL — «boost/interprocess».
Расписывать внутреннее устройство смысла нет. Некоторые основные пункты:

  • для всякого потока хранится свой список нынешних блокировок, для пренебрежения реентабельных блокировок
  • граф хранится в разделяемой памяти процесса

Применение банально:

#define ENABLE_DEADLOCK_CHECKER
/**/
#include "deadlock_checker.h"
/*класс блокировщик ресурса*/
class guard
{
     guard()
  {
    deadlock_checker_t::push(this);
  } 
    ~guard()
  {
    deadlock_checker_t::pop(this);
  } 
};

P.S. Всё закончилось отлично. Я отловил deadlock. Познал дао сего программного продукта и отключил модуль контроля за ненадобностью.

рабочий код


/*
*	динамический поиск  возможных взаимо- блокировок. 
*/
#pragma once
#include <assert.h>
#include <stack>
#include <map>
#include <vector>
#include <boost/thread/mutex.hpp>
#include <boost/thread/tss.hpp>
#include <boost/thread/once.hpp>
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/depth_first_search.hpp>
#include <boost/graph/visitors.hpp>
#include <boost/filesystem.hpp>
#include <boost/interprocess/managed_shared_memory.hpp>
#ifdef _DEBUG
//#define ENABLE_DEADLOCK_CHECKER
#endif
namespace deadlock_checker
{

    inline unsigned long get_current_process_id()
    {  
        return GetCurrentProcessId(); 
    }

    template<typename T>
    struct deadlock_graph_i
    {
        virtual bool _cdecl insert(const void* locker_child, const void* locker_root) = 0;
    };
    /***/
    template<typename T>
    class deadlock_graph : public deadlock_graph_i<T>
    {
        struct cycle_detector : public ::boost::dfs_visitor<>
        {
            cycle_detector(bool& has_cycle) 
                : m_has_cycle(has_cycle) { }

            template <class Edge, class Graph>
            void back_edge(Edge, Graph&) { m_has_cycle = true; 
            }
        protected:
            bool& m_has_cycle;
        };
        typedef ::boost::adjacency_list<::boost::mapS, ::boost::mapS, ::boost::bidirectionalS,
            ::boost::property<::boost::vertex_color_t, ::boost::default_color_type> > Graph;
        typedef typename ::boost::graph_traits<Graph>::vertex_descriptor vertex_descriptor;
        typedef typename ::boost::graph_traits<Graph>::edge_descriptor edge_descriptor;
        typedef const void* type_value;
    public:
        ::boost::mutex _mutex; 
        Graph _graph;
        ::std::map<type_value, vertex_descriptor> _vertex;
        //std::vector < ::boost::default_color_type > _color_map;
    public:
        deadlock_graph()
        {
        }
        /***/
        bool _cdecl insert(const void* locker_child, const void* locker_root)
        {
            using namespace ::boost;
            using namespace ::std;
mutex::scoped_lock scoped_lock(_mutex);

            if(_vertex.end() == _vertex.find(locker_child))
            {
                _vertex.insert(make_pair(locker_child, add_vertex(_graph) ));
            }

            if(_vertex.end() == _vertex.find(locker_root))
            {
                _vertex.insert(make_pair(locker_root, add_vertex(_graph) ));
            }
            vertex_descriptor vertex_child = _vertex[locker_child];
            pair<edge_descriptor, bool> ret = add_edge(vertex_child,_vertex[locker_root],_graph);
            if(ret.second)
            {
                bool has_cycle = false;
                cycle_detector vis(has_cycle);
                //_color_map.resize(num_vertices(_graph)); //= color_map(num_vertices(_graph));
                //::std::fill(_color_map.begin(),_color_map.end(),white_color);

                graph_traits<Graph>::vertex_iterator vi, vi_end;
                for (tie(vi, vi_end) = vertices(_graph); vi != vi_end;   vi)
                    get(vertex_color, _graph)[*vi] = white_color;

                depth_first_visit(_graph, vertex_child, vis,
                    get(vertex_color, _graph) );
                if(has_cycle)
                {
                    // зачищаем граф, для построения снова.
                    _graph.clear();
                    _vertex.clear();

                }
                return !has_cycle;
            }
            return true;
        }

    };
    inline char const* deadlock_shared_key()
    {
        return "1958EF20-6689-4e7b-9C53-3C115BCCF465";
    }
    /***/
    template<typename T>
    class deadlock_graph_common
    {
        deadlock_graph<T> _graph;
        deadlock_graph_i<T>* _graph_ptr;
        // флаг глобального применения
        bool _graph_main;
    public:
        deadlock_graph_common()
            : _graph_main(false)
            , _graph_ptr(NULL)
        {
            using namespace boost::interprocess;
            char process_id_str[20];
            if(0 != _itoa_s(GetCurrentProcessId(),process_id_str,boost::size(process_id_str),10))
            {
                throw ::std::runtime_error("error itoa()");
            }; 
            managed_shared_memory shmem(open_or_create, deadlock_shared_key(), 1024);    
            _graph_ptr = *shmem.find_or_construct<deadlock_graph<T>*>(process_id_str)(&_graph);
            _graph_main = _graph_ptr == &_graph;
        }
        ~deadlock_graph_common()
        {
            using namespace boost::interprocess;
            try
            {
                if(_graph_main)
                {
                    char process_id_str[20];
                    if(0 == _itoa_s(GetCurrentProcessId(),process_id_str,sizeof(process_id_str),10))
                    {
                        managed_shared_memory shmem(open_only, deadlock_shared_key());    
                        shmem.destroy<deadlock_graph<T>*>(process_id_str);
                    }; 
                }
            }
            catch(...)
            {
            }
        }
        deadlock_graph_i<T>* operator->()
        {
            return _graph_ptr;
        }
    };
    /**главный граф*/
    template<typename T>
    class main
    {
        deadlock_graph<T> _graph;
    public:
        main()
        {
            using namespace boost::interprocess;
            char process_id_str[20];
            if(0 != _itoa_s(get_current_process_id(),process_id_str,sizeof(process_id_str),10))
            {
                throw ::std::runtime_error(__FUNCTION__);
            }

            managed_shared_memory shmem(open_or_create, deadlock_shared_key(), 1024);    
            shmem.construct<deadlock_graph<T>*>(process_id_str)(&_graph);

        }
    };
    /**глобальный интерфейс*/
    template<typename T>
    class checker
    {
    private:
        /**глобальная ссылка на основной граф.*/
        struct main_ref
        {
            deadlock_graph_i<T>* & _graph_ptr;
        public:
            main_ref(deadlock_graph_i<T>* & graph_ptr)
                : _graph_ptr(graph_ptr)
            {
            }
            void operator()() const
            {
                using namespace boost::interprocess;
                char process_id_str[20];
                if(0 != _itoa_s(get_current_process_id(),process_id_str,boost::size(process_id_str),10))
                {
                    throw ::std::runtime_error(__FUNCTION__);
                }
                managed_shared_memory shmem(open_read_only, deadlock_shared_key());    
                _graph_ptr = *shmem.find<deadlock_graph<T>*>(process_id_str).first;
                if(!_graph_ptr)
                {
                    throw ::std::runtime_error(__FUNCTION__);
                }
            }
        };
    private:
        static boost::thread_specific_ptr<::std::stack<void*> > _stack;
        static deadlock_graph_i<T>* _graph_ptr;
        static boost::once_flag     _graph_flag;
    public:
        static bool push(T* locker, char* name)
        {
            if(!push(locker))
            {
                // логируем потенциальную взимо-блокировку.
                if(::boost::filesystem::file_exist())
                {
                }
            }
        }
        /***/
        static bool push(void* locker)
        {
            bool cycle_error = false;
            init_thread();
            ::std::stack<void*>* lockers = _stack.get();
            assert(lockers && lockers->size() < 8);
            if(lockers->size() > 0)
            {
                void* locker_root = lockers->top();
                if(locker_root != locker)
                {
                    // логируем потенциальную взаимо-блокировку.
                    char const * filename = ".\\Data\\deadlock.log";
                    if(!::boost::filesystem::is_regular_file(filename))
                    {
                        // вставляем ребро в граф.
                        cycle_error = !_graph_ptr->insert(locker,locker_root);
                        assert(!cycle_error && "потенциальный deadlock");
                        if(cycle_error)
                        {
                            ::std::ofstream file(filename);
                            if(file.is_open())
                            {
                                file << "найдена возможный deadlock" << ::std::endl;
                            }
                        }
                    }
                }
            }
            lockers->push(locker);
            return cycle_error;
        };
        /***/
        static void pop(void* locker = 0)
        {
            ::std::stack<void*>* lockers = _stack.get();
            assert(lockers && !lockers->empty());
            assert(!locker || lockers->top() == locker);
            if(!lockers->empty())
            {
                lockers->pop();
            };
        };
    private:
        /***/
        static void init_thread()
        {
            if(!_stack.get())
            {
                boost::call_once(_graph_flag, main_ref(_graph_ptr));
                _stack.reset(new ::std::stack<T*>);
            }
        }
    };

    template<typename T>
    boost::thread_specific_ptr<::std::stack<void*> > checker<T>::_stack;
    template<typename T>
    deadlock_graph_i<T>* checker<T>::_graph_ptr;
    template<typename T>
    boost::once_flag       checker<T>::_graph_flag;

    template<>
    class checker<bool>
    {
    public:
        static bool push(void* /*locker*/, char* /*name*/)
        {
            return true;
        }
        /***/
        static bool push(void* /*locker*/)
        {
            return true;
        };
        /***/
        static void pop(void* /*locker*/ = 0)
        {
        };
    };
    template<>
    class main<bool>
    {
    };
}

#if defined(ENABLE_DEADLOCK_CHECKER)
typedef deadlock_checker::checker<void> deadlock_checker_t;
typedef deadlock_checker::main<void> deadlock_checker_main_t;
#else
typedef deadlock_checker::checker<bool> deadlock_checker_t;
typedef deadlock_checker::main<bool> deadlock_checker_main_t;
#endif

 

Источник: programmingmaster.ru

 

Оставить комментарий
Форум phpBB, русская поддержка форума phpBB
Рейтинг@Mail.ru 2008 - 2017 © BB3x.ru - русская поддержка форума phpBB