summaryrefslogtreecommitdiff
path: root/src/mongo/db/memconcept.cpp
blob: 3d3ebe7203213b70391027b63dfbd0e94c5da1f5 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
#include "pch.h"

#if 1

#define DDD(x) 

#include <string>
#include <map>
#include "memconcept.h"
#include "../util/assert_util.h"
#include <boost/functional/hash.hpp>
using namespace std;
#include "../util/log.h"
#include "../util/startup_test.h"

namespace mongo {
    namespace memconcept { 

        concept::concept(const char * desc) : c(desc) { }

        // these string pointers we use as unique identifiers - like enums. thus it is important
        // you don't use another with the same literal name 
        concept concept::err("err");
        concept concept::something("something");
        concept concept::database("database");
        concept concept::other("other");
        concept concept::memorymappedfile("memorymappedfile");
        concept concept::nsdetails("nsdetails");
        concept concept::datafileheader("datafileheader");
        concept concept::extent("extent");
        concept concept::record("record");
        concept concept::deletedrecord("deletedrecord");
        concept concept::btreebucket("btreebucket");

        class X : public StartupTest { 
        public:
            virtual void run() {
            }
        } concepttest;

        struct C { 
            void *p;
            unsigned len;
            concept c;
            char desc[16];
            string toString() const;
        };

        string C::toString() const { 
            stringstream ss;
            ss << p << ' ' << c.toString() << ' ' << len << ' ' << desc;
            return ss.str();
        }

        const int N = 100003;

        class map { 
            C nodes[N];
            boost::hash<void *> h;
        public:
            C& find(void *p) { 
                unsigned x = h(p);
                return nodes[x % N];
            }
            map() { 
                memset(this, 0, sizeof(*this));
                for( int i = 0; i < N; i++ )
                    nodes[i].c = concept::err;
            }
            void dump();
        } map;

        void map::dump() {
            // sort
            std::map<void*,C*> m;
            for( int i = 0; i < N; i++ ) { 
                if( nodes[i].p ) { 
                    m[ nodes[i].p ] = &nodes[i];
                }
            }
            // print
            for( std::map<void*,C*>::const_iterator i = m.begin(); i != m.end(); i++ ) { 
                log() << i->second->toString() << endl;
            }
        }

#if 0 && defined(_DEBUG)
        bool d = false;
        void is(void *p, concept c, const std::string& description, unsigned len) {
            DDD( log() << "is  " << p << ' ' << c.toString() << ' ' << description << ' ' << len << endl; )
            C &node = map.find(p);
            node.p = p;
            node.c = c;
            node.len = len;
            strncpy(node.desc, description.c_str(), 15);
        }

        void invalidate(void *p, unsigned len) {
            DDD( log() << "inv " << p << " invalidate" << endl; )
            C &node = map.find(p);
            node.p = p;
            node.c = concept::err;
            // len is not used currenntly. hmmm.
        }
#endif

    }
}

#endif