slideshow/source/engine/sp_debug.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21
  22 //  sp_collector.cpp
  23
  24 //  Copyright (c) 2002, 2003 Peter Dimov
  25
  26 //  Permission to copy, use, modify, sell and distribute this software
  27 //  is granted provided this copyright notice appears in all copies.
  28 //  This software is provided "as is" without express or implied
  29 //  warranty, and with no claim as to its suitability for any purpose.
  30
  31
  32 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
  33
  34 #include <boost/assert.hpp>
  35 #include <boost/scoped_array.hpp>
  36 #include <boost/scoped_ptr.hpp>
  37 #include <boost/shared_ptr.hpp>
  38 #include <boost/detail/lightweight_mutex.hpp>
  39 #include <canvas/debug.hxx>
  40 #include <cstdlib>
  41 #include <map>
  42 #include <deque>
  43 #include <iostream>
  44
  45 typedef std::map< void const *, std::pair<void *, size_t> > map_type;
  46
  47 static map_type & get_map()
  48 {
  49     static map_type m;
  50     return m;
  51 }
  52
  53 typedef boost::detail::lightweight_mutex mutex_type;
  54
  55 static mutex_type & get_mutex()
  56 {
  57     static mutex_type m;
  58     return m;
  59 }
  60
  61 static void * init_mutex_before_main = &get_mutex();
  62
  63 namespace
  64 {
  65     class X;
  66
  67     struct count_layout
  68     {
  69         boost::detail::sp_counted_base * pi;
  70         int id;
  71     };
  72
  73     struct shared_ptr_layout
  74     {
  75         X * px;
  76         count_layout pn;
  77     };
  78 }
  79
  80 // assume 4 byte alignment for pointers when scanning
  81 size_t const pointer_align = 4;
  82
  83 typedef std::map<void const *, long> map2_type;
  84
  85 static void scan_and_count(void const * area, size_t size, map_type const & m, map2_type & m2)
  86 {
  87     unsigned char const * p = static_cast<unsigned char const *>(area);
  88
  89     for(size_t n = 0; n + sizeof(shared_ptr_layout) <= size; p += pointer_align, n += pointer_align)
  90     {
  91         shared_ptr_layout const * q = reinterpret_cast<shared_ptr_layout const *>(p);
  92
  93         if(q->pn.id == boost::detail::shared_count_id && q->pn.pi != 0 && m.count(q->pn.pi) != 0)
  94         {
  95             ++m2[q->pn.pi];
  96         }
  97     }
  98 }
  99
 100 typedef std::deque<void const *> open_type;
 101
 102 static void scan_and_mark(void const * area, size_t size, map2_type & m2, open_type & open)
 103 {
 104     unsigned char const * p = static_cast<unsigned char const *>(area);
 105
 106     for(size_t n = 0; n + sizeof(shared_ptr_layout) <= size; p += pointer_align, n += pointer_align)
 107     {
 108         shared_ptr_layout const * q = reinterpret_cast<shared_ptr_layout const *>(p);
 109
 110         if(q->pn.id == boost::detail::shared_count_id && q->pn.pi != 0 && m2.count(q->pn.pi) != 0)
 111         {
 112             open.push_back(q->pn.pi);
 113             m2.erase(q->pn.pi);
 114         }
 115     }
 116 }
 117
 118 static void find_unreachable_objects_impl(map_type const & m, map2_type & m2)
 119 {
 120     // scan objects for shared_ptr members, compute internal counts
 121
 122     {
 123         std::cout << "... " << m.size() << " objects in m.\n";
 124
 125         for(map_type::const_iterator i = m.begin(); i != m.end(); ++i)
 126         {
 127             BOOST_ASSERT(static_cast<boost::detail::sp_counted_base const *>(i->first)->use_count() != 0); // there should be no inactive counts in the map
 128
 129             scan_and_count(i->second.first, i->second.second, m, m2);
 130         }
 131
 132         std::cout << "... " << m2.size() << " objects in m2.\n";
 133     }
 134
 135     // mark reachable objects
 136
 137     {
 138         open_type open;
 139
 140         for(map2_type::iterator i = m2.begin(); i != m2.end(); ++i)
 141         {
 142             boost::detail::sp_counted_base const * p = static_cast<boost::detail::sp_counted_base const *>(i->first);
 143             if(p->use_count() != i->second) open.push_back(p);
 144         }
 145
 146         std::cout << "... " << m2.size() << " objects in open.\n";
 147
 148         for(open_type::iterator j = open.begin(); j != open.end(); ++j)
 149         {
 150             m2.erase(*j);
 151         }
 152
 153         while(!open.empty())
 154         {
 155             void const * p = open.front();
 156             open.pop_front();
 157
 158             map_type::const_iterator i = m.find(p);
 159             BOOST_ASSERT(i != m.end());
 160
 161             scan_and_mark(i->second.first, i->second.second, m2, open);
 162         }
 163     }
 164
 165     // m2 now contains the unreachable objects
 166 }
 167
 168 std::size_t find_unreachable_objects(bool report)
 169 {
 170     map2_type m2;
 171
 172 #ifdef BOOST_HAS_THREADS
 173
 174     // This will work without the #ifdef, but some compilers warn
 175     // that lock is not referenced
 176
 177     mutex_type::scoped_lock lock(get_mutex());
 178
 179 #endif
 180
 181     map_type const & m = get_map();
 182
 183     find_unreachable_objects_impl(m, m2);
 184
 185     if(report)
 186     {
 187         for(map2_type::iterator j = m2.begin(); j != m2.end(); ++j)
 188         {
 189             map_type::const_iterator i = m.find(j->first);
 190             BOOST_ASSERT(i != m.end());
 191             std::cout << "Unreachable object at " << i->second.first << ", " << i->second.second << " bytes long.\n";
 192         }
 193     }
 194
 195     return m2.size();
 196 }
 197
 198 // debug hooks
 199
 200 namespace boost
 201 {
 202
 203 void sp_scalar_constructor_hook(void *)
 204 {
 205 }
 206
 207 void sp_scalar_constructor_hook(void * px, std::size_t size, void * pn)
 208 {
 209 #ifdef BOOST_HAS_THREADS
 210
 211     mutex_type::scoped_lock lock(get_mutex());
 212
 213 #endif
 214
 215     get_map()[pn] = std::make_pair(px, size);
 216 }
 217
 218 void sp_scalar_destructor_hook(void *)
 219 {
 220 }
 221
 222 void sp_scalar_destructor_hook(void *, std::size_t, void * pn)
 223 {
 224 #ifdef BOOST_HAS_THREADS
 225
 226     mutex_type::scoped_lock lock(get_mutex());
 227
 228 #endif
 229
 230     get_map().erase(pn);
 231 }
 232
 233 void sp_array_constructor_hook(void *)
 234 {
 235 }
 236
 237 void sp_array_destructor_hook(void *)
 238 {
 239 }
 240
 241 } // namespace boost
 242
 243 #endif // defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
 244
 245 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */