root/OpenSceneGraph/trunk/examples/osgmemorytest/osgmemorytest.cpp @ 9140

Revision 9140, 9.0 kB (checked in by robert, 6 years ago)

First cut of osgmemorytest example that is written to allocate many windows/pbuffer/GL objects as test of how many objects can be allocated on a machine.

Line 
1/* OpenSceneGraph example, osganimate.
2*
3*  Permission is hereby granted, free of charge, to any person obtaining a copy
4*  of this software and associated documentation files (the "Software"), to deal
5*  in the Software without restriction, including without limitation the rights
6*  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7*  copies of the Software, and to permit persons to whom the Software is
8*  furnished to do so, subject to the following conditions:
9*
10*  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
11*  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
12*  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
13*  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
14*  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
15*  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
16*  THE SOFTWARE.
17*/
18
19#include <osg/Notify>
20#include <osg/ArgumentParser>
21#include <osg/Texture1D>
22#include <osg/Texture2D>
23#include <osg/Texture3D>
24
25#include <osgViewer/Viewer>
26
27class MemoryTest : public osg::Referenced
28{
29    public:
30};
31
32class GLMemoryTest : public MemoryTest
33{
34    public:
35        virtual void allocate(osg::State& state) = 0;
36};
37
38class ContextTest : public MemoryTest
39{
40    public:
41        virtual osg::GraphicsContext* allocate() = 0;
42};
43
44/////////////////////////////////////////////////////////////////////////
45//
46// PBuffer test
47class PBufferTest : public ContextTest
48{
49    public:
50        PBufferTest(int width, int height):
51            _width(width),
52            _height(height) {}
53       
54        virtual bool requiresContext() { return false; }
55        virtual osg::GraphicsContext* allocate()
56        {
57            osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits;
58            traits->width = _width;
59            traits->height = _height;
60            traits->pbuffer = true;
61           
62            osg::ref_ptr<osg::GraphicsContext> pbuffer = osg::GraphicsContext::createGraphicsContext(traits.get());
63            if (pbuffer.valid())
64            {
65                if (pbuffer->realize())
66                {
67                    pbuffer->makeCurrent();
68                    pbuffer->releaseContext();
69
70                    return pbuffer.release();
71                }
72                else
73                {
74                    throw "Failed to realize Pixelbuffer";
75                }
76            }
77            else
78            {
79                throw "Failed to created PixelBuffer";
80            }
81            return 0;
82        }
83       
84
85    protected:
86   
87        int     _width;
88        int     _height;
89};
90
91/////////////////////////////////////////////////////////////////////////
92//
93// Window test
94class WindowTest : public ContextTest
95{
96    public:
97        WindowTest(int width, int height):
98            _width(width),
99            _height(height) {}
100       
101        virtual bool requiresContext() { return false; }
102        virtual osg::GraphicsContext* allocate()
103        {
104            osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits;
105            traits->width = _width;
106            traits->height = _height;
107            traits->windowDecoration = true;
108           
109            osg::ref_ptr<osg::GraphicsContext> window = osg::GraphicsContext::createGraphicsContext(traits.get());
110            if (window.valid())
111            {
112                if (window->realize())
113                {
114                    window->makeCurrent();
115                    window->releaseContext();
116
117                    return window.release();
118                }
119                else
120                {
121                    throw "Failed to realize GraphicsWindow";
122                }
123            }
124            else
125            {
126                throw "Failed to created GraphicsWindow";
127            }
128            return 0;
129        }
130       
131
132    protected:
133   
134        int     _width;
135        int     _height;
136};
137
138
139/////////////////////////////////////////////////////////////////////////
140//
141// Window test
142class TextureTest : public GLMemoryTest
143{
144    public:
145        TextureTest(int width=1, int height=1, int depth=1):
146            _width(width),
147            _height(height),
148            _depth(depth) {}
149       
150        virtual bool requiresContext() { return true; }
151       
152        virtual void allocate(osg::State& state)
153        {
154            if (_depth>1)
155            {
156                osg::ref_ptr<osg::Image> image = new osg::Image;
157                image->allocateImage(_width, _height, _depth, GL_RGBA, GL_UNSIGNED_BYTE);
158               
159                osg::ref_ptr<osg::Texture3D> texture = new osg::Texture3D;
160                texture->setImage(image.get());
161               
162                texture->apply(state);
163
164                _textures.push_back(texture.get());
165               
166            }
167            if (_height>1)
168            {
169                osg::ref_ptr<osg::Image> image = new osg::Image;
170                image->allocateImage(_width, _height, 1, GL_RGBA, GL_UNSIGNED_BYTE);
171               
172                osg::ref_ptr<osg::Texture2D> texture = new osg::Texture2D;
173                texture->setImage(image.get());
174               
175                texture->apply(state);
176
177                _textures.push_back(texture.get());
178            }
179            if (_width>1)
180            {
181                osg::ref_ptr<osg::Image> image = new osg::Image;
182                image->allocateImage(_width, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE);
183               
184                osg::ref_ptr<osg::Texture1D> texture = new osg::Texture1D;
185                texture->setImage(image.get());
186               
187                texture->apply(state);
188
189                _textures.push_back(texture.get());
190            }
191            else
192            {
193                throw "Invalid texture size of 0,0,0.";
194            }
195           
196        }
197       
198
199    protected:
200   
201        virtual ~TextureTest()
202        {
203        }
204       
205        typedef std::list< osg::ref_ptr<osg::Texture> > Textures;
206        Textures _textures;
207        int     _width;
208        int     _height;
209        int     _depth;
210};
211
212int main( int argc, char **argv )
213{
214    osg::ArgumentParser arguments(&argc,argv);
215   
216    typedef std::list< osg::ref_ptr<MemoryTest> > Tests;
217    Tests tests;
218   
219    int width, height, depth;
220    while(arguments.read("--pbuffer",width,height)) { tests.push_back(new PBufferTest(width,height)); }
221    while(arguments.read("--pbuffer")) { tests.push_back(new PBufferTest(1024,1024)); }
222
223    while(arguments.read("--window",width,height)) { tests.push_back(new WindowTest(width,height)); }
224    while(arguments.read("--window")) { tests.push_back(new WindowTest(1024,1024)); }
225
226    while(arguments.read("--texture",width,height,depth)) { tests.push_back(new TextureTest(width,height,depth)); }
227    while(arguments.read("--texture",width,height)) { tests.push_back(new TextureTest(width,height,1)); }
228    while(arguments.read("--texture",width)) { tests.push_back(new TextureTest(width,1,1)); }
229
230    int maxNumContextIterations = 1000;
231    while(arguments.read("-c",maxNumContextIterations)) {}
232
233    int maxNumGLIterations = 1000;
234    while(arguments.read("-g",maxNumGLIterations)) {}
235
236    typedef std::list< osg::ref_ptr<GLMemoryTest> > GLMemoryTests;
237    typedef std::list< osg::ref_ptr<ContextTest> > ContextTests;
238
239
240   
241    ContextTests contextTests;
242    GLMemoryTests glMemoryTests;
243   
244    for(Tests::iterator itr = tests.begin();
245        itr != tests.end();
246        ++itr)
247    {
248        MemoryTest* test = itr->get();
249        if (dynamic_cast<GLMemoryTest*>(test)!=0)
250        {
251            glMemoryTests.push_back(dynamic_cast<GLMemoryTest*>(test));
252        }
253        else if (dynamic_cast<ContextTest*>(test)!=0)
254        {
255            contextTests.push_back(dynamic_cast<ContextTest*>(test));
256        }
257    }
258
259    typedef std::list< osg::ref_ptr<osg::GraphicsContext> > Contexts;
260    Contexts allocatedContexts;
261
262    int numContextIterations = 0;
263    try
264    {
265        for(;numContextIterations<maxNumContextIterations; ++numContextIterations)
266        {
267            printf("iteration %i\n",numContextIterations);
268            for(ContextTests::iterator itr = contextTests.begin();
269                itr != contextTests.end();
270                ++itr)
271            {
272                osg::ref_ptr<osg::GraphicsContext> context = (*itr)->allocate();
273                if (context.valid())
274                {
275                    context->makeCurrent();
276                    context->releaseContext();
277                   
278                    allocatedContexts.push_back(context);
279                }
280            }
281        }
282    }
283    catch(const char* errorString)
284    {
285        printf("Exception caught, number of iterations completed = %i, error = %s\n",numContextIterations, errorString);
286        return 1;
287    }
288    catch(...)
289    {
290        printf("Exception caught, number of iterations completed = %i\n",numContextIterations);
291        return 1;
292    }
293
294    printf("Successful completion, number of iterations completed = %i\n",numContextIterations);
295   
296    return 0;
297}
Note: See TracBrowser for help on using the browser.