Text archives Help

---

Author: bigler
Date: Tue Jul 10 16:42:06 2007
New Revision: 1460

Added:
   trunk/Core/Math/CheapRNG.cc
Modified:
   trunk/Core/CMakeLists.txt
   trunk/Core/Math/CheapRNG.h
   trunk/Core/Util/ThreadStorage.h
   trunk/Engine/Control/RTRT.cc
   trunk/Engine/Control/RTRT.h
   trunk/Interface/Context.h
   trunk/Interface/MantaInterface.h
Log:

Core/CMakeLists.txt

  Added CheapRNG (used to be header only).

  Alphabetized Core sources.

Core/Math/CheapRNG.cc

  Added.  Will have some stuff in here when we do SSE.

Core/Math/CheapRNG.h

  Added some padding.

  Change the create function to be more Callback API friendly.

Core/Util/ThreadStorage.h

  Return NULL for compiler warning.

Engine/Control/RTRT.cc
Engine/Control/RTRT.h

  Allocate a set of RandomNumberGenerators and pass them into the
  RenderContext.

Interface/Context.h

  Added RandomNumberGenerator to RenderContext.

Interface/MantaInterface.h

  Added interface for RandomNumberGenerator creator callback.

  Removed FixedSamplingRate from TimeMode enumeration.


Modified: trunk/Core/CMakeLists.txt
==============================================================================
--- trunk/Core/CMakeLists.txt   (original)
+++ trunk/Core/CMakeLists.txt   Tue Jul 10 16:42:06 2007
@@ -42,16 +42,18 @@
      Geometry/vecdefs.h
      )
 SET (CORE_SOURCES ${CORE_SOURCES}
+     Math/CatmullRomInterpolator.h
+     Math/CheapRNG.cc
+     Math/CheapRNG.h
      Math/HaltonSequence.cc
      Math/HaltonSequence.h
-     Math/MT_RNG.h
      Math/MT_RNG.cc
-     Math/Noise.h
+     Math/MT_RNG.h
      Math/Noise.cc
-     Math/ipow.h
-     Math/CatmullRomInterpolator.h
-     Math/SSEDefs.h
+     Math/Noise.h
      Math/SSEDefs.cc
+     Math/SSEDefs.h
+     Math/ipow.h
      )
 SET (CORE_SOURCES ${CORE_SOURCES}
      Util/AlignedAllocator.h

Added: trunk/Core/Math/CheapRNG.cc
==============================================================================
--- (empty file)
+++ trunk/Core/Math/CheapRNG.cc Tue Jul 10 16:42:06 2007
@@ -0,0 +1,4 @@
+#include <Core/Math/CheapRNG.h>
+
+using namespace Manta;
+

Modified: trunk/Core/Math/CheapRNG.h
==============================================================================
--- trunk/Core/Math/CheapRNG.h  (original)
+++ trunk/Core/Math/CheapRNG.h  Tue Jul 10 16:42:06 2007
@@ -66,12 +66,13 @@
     typedef unsigned int uint32;
   protected:
     
+    char padding0 [128];
     uint32 val;
-    
+    char padding1 [128];
   public:
     // Your seed value is up to the fates.  You should call seed.
     CheapRNG() {}
-    static RandomNumberGenerator* create() { return new CheapRNG(); }
+    static void create(RandomNumberGenerator*& rng ) { rng = new CheapRNG(); 
}
       
     virtual void seed(unsigned int seed_val) {
       val = seed_val;
@@ -83,4 +84,4 @@
     }
   }; // end class CheapRNG
 
-}
+} // end namespace Manta

Modified: trunk/Core/Util/ThreadStorage.h
==============================================================================
--- trunk/Core/Util/ThreadStorage.h     (original)
+++ trunk/Core/Util/ThreadStorage.h     Tue Jul 10 16:42:06 2007
@@ -132,6 +132,7 @@
         ASSERT(token.offset+token.size <= requested)
         return storage[proc]+token.offset;
       }
+      return NULL;
     }
     
     // Called by each thread to allocate its memory. Will reallocate if 
necessary.

Modified: trunk/Engine/Control/RTRT.cc
==============================================================================
--- trunk/Engine/Control/RTRT.cc        (original)
+++ trunk/Engine/Control/RTRT.cc        Tue Jul 10 16:42:06 2007
@@ -145,7 +145,7 @@
   scene = 0;
   verbose_transactions = false;
 
-  create_rng = &CheapRNG::create;
+  create_rng = Callback::create(&CheapRNG::create);
 }
 
 RTRT::~RTRT()
@@ -439,6 +439,7 @@
 
   // Start up all of the Worker threads.
   workers.resize(workersWanted);
+  rngs.resize(workersWanted);
   changedFlags.resize(workersWanted);
   for(int i=0;i<workersWanted;i++){
     if(i>0 || !blockUntilFinished){
@@ -449,6 +450,9 @@
       t->setStackSize(RENDER_THREAD_STACKSIZE);
       t->activate(false);
       workers[i] = t;
+    }      
+    if (create_rng) {
+      create_rng->call(rngs[i]);
     }
   }
 
@@ -531,13 +535,14 @@
     doParallelAnimationCallbacks(changed, proc, workersAnimAndImage);
 
     if(!firstFrame){
-      for(int index = 0;index < static_cast<int>(channels.size());index++){
+      for(size_t index = 0;index < channels.size();index++){
         Channel* channel = channels[index];
         RenderContext myContext(this, index, proc, workersAnimAndImage,
                                 &animFrameState,
                                 currentLoadBalancer, currentPixelSampler,
                                 currentRenderer, currentShadowAlgorithm,
-                                channel->camera, scene, thread_storage );
+                                channel->camera, scene, thread_storage,
+                                rngs[index]);
         currentImageTraverser->setupFrame(myContext);
       }
     }
@@ -558,6 +563,7 @@
         // section of this loop for the first frame
         workersChanged = true;
         workers.resize(newWorkers);
+        rngs.resize(newWorkers);
         int oldworkers = workersRendering;
         workersRendering = workersWanted;
         for(int i=oldworkers;i<newWorkers;i++){
@@ -567,10 +573,12 @@
                                   0, Thread::NotActivated);
           workers[i]->setStackSize(RENDER_THREAD_STACKSIZE);
           workers[i]->activate(false);
+          if (create_rng) create_rng->call(rngs[i]);
         }
       } else if(newWorkers < workersRendering) {
         workersChanged = true;
         workersRendering = workersWanted;
+        // TODO(bigler,boulos): should we get rid of our random number 
generators.
       } else {
         // Don't set it to false if it is already false - avoids
         // flushing the other caches
@@ -619,7 +627,7 @@
         // Allocate thread local storage for each thread.
         thread_storage->allocateStorage( proc );
         
-        for(int index = 0;index < static_cast<int>(channels.size());index++){
+        for(size_t index = 0;index < channels.size();index++){
           Channel* channel = channels[index];
           RenderContext myContext(this, index, proc, workersAnimAndImage,
                                   &animFrameState,
@@ -629,7 +637,8 @@
                                   currentShadowAlgorithm,
                                   channel->camera,
                                   scene,
-                                  thread_storage );
+                                  thread_storage,
+                                  rngs[index]);
 
           currentImageTraverser->setupFrame(myContext);
         }
@@ -686,14 +695,15 @@
     //if(!idle){
     // #endif
     {
-      for(int index = 0;index < static_cast<int>(channels.size());index++){
+      for(size_t index = 0;index < channels.size();index++){
         Channel* channel = channels[index];
         long renderFrame = 
renderFrameState.frameNumber%channel->pipelineDepth;
         Image* image = channel->images[renderFrame];
         RenderContext myContext(this, index, proc, workersRendering, 
&renderFrameState,
                                 currentLoadBalancer, currentPixelSampler,
                                 currentRenderer, currentShadowAlgorithm,
-                                channel->camera, scene, thread_storage );
+                                channel->camera, scene, thread_storage,
+                                rngs[index]);
         currentImageTraverser->renderImage(myContext, image);
       }
     }
@@ -807,7 +817,6 @@
     transaction_lock.lock();
     changed = true;
 
-    int flag = 0;
     while (transactions.size()) {
       // Pop the first transaction from the queue.
       TransactionBase *transaction = *(transactions.begin());
@@ -1123,10 +1132,11 @@
 }
 
 // Random Number Generator
-void RTRT::setRNGCreator( RNGCreator const callback ) {
+void RTRT::setCreateRNGCallback( CreateRNGCallback* const callback ) {
+  // TODO(bigler): clean up the old ones and allocate the new ones.
   create_rng = callback;
 }
-MantaInterface::RNGCreator RTRT::getRNGCreator() const {
+MantaInterface::CreateRNGCallback* RTRT::getCreateRNGCallback() const {
   return create_rng;
 }
 
@@ -1225,7 +1235,8 @@
   RenderContext render_context(this, channel_index, workersRendering, 0, 0,
                                currentLoadBalancer, currentPixelSampler,
                                currentRenderer, currentShadowAlgorithm,
-                               channel->camera, scene, thread_storage );
+                               channel->camera, scene, thread_storage,
+                               rngs[0]);
 
   // Send this to the renderer.  It will fill in the colors for us.
   currentRenderer->traceEyeRays( render_context, result_rays );

Modified: trunk/Engine/Control/RTRT.h
==============================================================================
--- trunk/Engine/Control/RTRT.h (original)
+++ trunk/Engine/Control/RTRT.h Tue Jul 10 16:42:06 2007
@@ -89,8 +89,8 @@
     virtual CreateImageCallback * getCreateImageCallback() const;
 
     // Random Number Generator
-    virtual void setRNGCreator( RNGCreator const callback );
-    virtual RNGCreator getRNGCreator() const;
+    virtual void setCreateRNGCallback( CreateRNGCallback* const callback );
+    virtual CreateRNGCallback* getCreateRNGCallback() const;
 
     // Load Balancers
     virtual void setLoadBalancer( LoadBalancer *load_balancer_ );
@@ -247,7 +247,7 @@
     vector<IdleMode*> currentIdleModes;
 
     CreateImageCallback* create_image;
-    RNGCreator   create_rng;
+    CreateRNGCallback*   create_rng;
     
   private:
     RTRT(const RTRT&);

Modified: trunk/Interface/Context.h
==============================================================================
--- trunk/Interface/Context.h   (original)
+++ trunk/Interface/Context.h   Tue Jul 10 16:42:06 2007
@@ -15,6 +15,7 @@
   class ShadowAlgorithm;
   class XWindow;
   class ThreadStorage;
+  class RandomNumberGenerator;
   
   class ReadContext {
   public:
@@ -153,14 +154,16 @@
                   LoadBalancer* loadBalancer, PixelSampler* pixelSampler,
                   Renderer* renderer, ShadowAlgorithm* shadowAlgorithm,
                   const Camera* camera, const Scene* scene,
-                  ThreadStorage *storage_allocator_ )
+                  ThreadStorage *storage_allocator_,
+                  RandomNumberGenerator* rng)
       : rtrt_int(rtrt_int), channelIndex(channelIndex),
         proc(proc), numProcs(numProcs),
         frameState(frameState),
         loadBalancer(loadBalancer), pixelSampler(pixelSampler),
         renderer(renderer), shadowAlgorithm(shadowAlgorithm),
         camera(camera), scene(scene),
-        storage_allocator( storage_allocator_ )
+        storage_allocator( storage_allocator_ ),
+        rng(rng)
     {
     }
     MantaInterface* rtrt_int;
@@ -177,6 +180,7 @@
 
     mutable ThreadStorage *storage_allocator;
     
+    RandomNumberGenerator* rng;
   private:
     RenderContext(const RenderContext&);
     RenderContext& operator=(const RenderContext&);

Modified: trunk/Interface/MantaInterface.h
==============================================================================
--- trunk/Interface/MantaInterface.h    (original)
+++ trunk/Interface/MantaInterface.h    Tue Jul 10 16:42:06 2007
@@ -48,8 +48,8 @@
   class CameraPath;
   class Group;
   class IdleMode;
-  class ImageDisplay;
   class Image;
+  class ImageDisplay;
   class ImageTraverser;
   class LoadBalancer;
   class PixelSampler;
@@ -107,9 +107,10 @@
     virtual CreateImageCallback* getCreateImageCallback() const = 0;
 
     // Random Number Generator
-    typedef RandomNumberGenerator*(*RNGCreator)();
-    virtual void setRNGCreator( RNGCreator const callback ) = 0;
-    virtual RNGCreator getRNGCreator() const = 0;
+    //typedef CacheLonelyRNG*(*RNGCreator)();
+    typedef CallbackBase_1Data<RandomNumberGenerator*&> CreateRNGCallback;
+    virtual void setCreateRNGCallback( CreateRNGCallback* const callback ) = 
0;
+    virtual CreateRNGCallback* getCreateRNGCallback() const = 0;
 
     // Load Balancers
     virtual void setLoadBalancer( LoadBalancer* load_balancer_ ) = 0;
@@ -140,8 +141,7 @@
     enum TimeMode {
       RealTime,
       FixedRate,
-      Static,
-      FixedSamplingRate
+      Static
     };
     virtual void setTimeMode(TimeMode tm, double rate) = 0;
 

---

• [MANTA] r1460 - in trunk: Core Core/Math Core/Util Engine/Control Interface, bigler, 07/10/2007

---

Archive powered by MHonArc 2.6.16.