Text archives Help

---

Author: boulos
Date: Thu Aug 10 11:11:30 2006
New Revision: 1163

Modified:
   trunk/Engine/ImageTraversers/TiledImageTraverser.cc
   trunk/Engine/ImageTraversers/TiledImageTraverser.h
   trunk/Engine/PixelSamplers/FastSampler.cc
   trunk/Engine/PixelSamplers/SingleSampler.cc
   trunk/Image/SimpleImage.h
   trunk/Image/SimpleImage_special.cc
Log:
Adding SquareShape Fragment as a possible output
for the TiledImageTraverser.

Fixing fragment.getFlag bugs in SimpleImage and 
the Samplers (this should be complete code 
coverage).


Modified: trunk/Engine/ImageTraversers/TiledImageTraverser.cc
==============================================================================
--- trunk/Engine/ImageTraversers/TiledImageTraverser.cc (original)
+++ trunk/Engine/ImageTraversers/TiledImageTraverser.cc Thu Aug 10 11:11:30 
2006
@@ -38,6 +38,7 @@
 #include <Interface/Image.h>
 #include <Interface/LoadBalancer.h>
 #include <Interface/PixelSampler.h>
+#include <Interface/RayPacket.h> // for maxsize
 #include <MantaSSE.h>
 
 using namespace Manta;
@@ -51,12 +52,21 @@
 {
   xtilesize = Fragment::MaxSize;
   ytilesize = Fragment::MaxSize;
+  shape = Fragment::LineShape;
   int argc = static_cast<int>(args.size());
   for(int i = 0; i<argc;i++){
     string arg = args[i];
     if(arg == "-tilesize"){
       if(!getResolutionArg(i, args, xtilesize, ytilesize))
         throw IllegalArgument("TiledImageTraverser -tilesize", i, args);
+    } else if (arg == "-square") {
+/*
+        int sqrt_size = static_cast<int>(sqrt(RayPacket::MaxSize));
+        if (sqrt_size * sqrt_size != RayPacket::MaxSize)
+            throw IllegalArgument("TiledImageTraverser -square 
(RayPacket::MaxSize is not square",
+                                  i, args);
+*/
+        shape = Fragment::SquareShape;
     } else {
       throw IllegalArgument("TiledImageTraverser", i, args);
     }
@@ -106,12 +116,12 @@
   int xres, yres;
   image->getResolution(stereo, xres, yres);
   int numEyes = stereo?2:1;
-  
+
   int s,e;
   while(context.loadBalancer->getNextAssignment(context, s, e)){
 
     for(int assignment = s; assignment < e; assignment++){
-      
+
       int xtile = assignment/ytiles;
       int ytile = assignment%ytiles;
       int xstart = xtile * xtilesize;
@@ -125,95 +135,139 @@
 
       if(yend > yres)
         yend = yres;
-      
+
 #ifdef MANTA_SSE
       __m128i vec_4 = _mm_set1_epi32(4);
       __m128i vec_cascade = _mm_set_epi32(3, 2, 1, 0);
 #endif
       // Create a Fragment that is consecutive in X pixels
-      Fragment frag(Fragment::LineShape, 
Fragment::ConsecutiveX|Fragment::ConstantEye);
-      int fsize = SCIRun::Min(Fragment::MaxSize, xend-xstart);
-      for(int eye = 0; eye < numEyes; eye++){
-#ifdef MANTA_SSE
-        // This finds the upper bound of the groups of 4.  Even if you
-        // write more than you need (say 8 for a fragment size of 6),
-        // you won't blow the top of the array, because
-        // (Fragment::MaxSize+3)&(~3) == Fragment::MaxSize.
-        int e = (fsize+3)&(~3);
-        __m128i vec_eye = _mm_set1_epi32(eye);
-        for(int i=0;i<e;i+=4)
-          _mm_store_si128((__m128i*)&frag.whichEye[i], vec_eye);
+      switch (shape) {
+      case Fragment::LineShape:
+      {
+          Fragment frag(Fragment::LineShape, 
Fragment::ConsecutiveX|Fragment::ConstantEye);
+
+          int fsize = SCIRun::Min(Fragment::MaxSize, xend-xstart);
+          for(int eye = 0; eye < numEyes; eye++){
+#ifdef MANTA_SSE
+              // This finds the upper bound of the groups of 4.  Even if you
+              // write more than you need (say 8 for a fragment size of 6),
+              // you won't blow the top of the array, because
+              // (Fragment::MaxSize+3)&(~3) == Fragment::MaxSize.
+              int e = (fsize+3)&(~3);
+              __m128i vec_eye = _mm_set1_epi32(eye);
+              for(int i=0;i<e;i+=4)
+                  _mm_store_si128((__m128i*)&frag.whichEye[i], vec_eye);
 #else
-        for(int i=0;i<fsize;i++)
-          frag.whichEye[i] = eye;
+              for(int i=0;i<fsize;i++)
+                  frag.whichEye[i] = eye;
 #endif
 
-        // Two versions.  If the assignment is narrower than a fragment, we
-        // can enable a few optimizations
-        if(xend-xstart <= Fragment::MaxSize){
-          // Common case - one packet in X direction
-          int size = xend-xstart;
-#ifdef MANTA_SSE
-          __m128i vec_x = _mm_add_epi32(_mm_set1_epi32(xstart), vec_cascade);
-          for(int i=0;i<size;i+=4){
-            // This will spill over by up to 3 pixels
-            _mm_store_si128((__m128i*)&frag.pixel[0][i], vec_x);
-            vec_x = _mm_add_epi32(vec_x, vec_4);
-          }
+              // Two versions.  If the assignment is narrower than a 
fragment, we
+              // can enable a few optimizations
+              if(xend-xstart <= Fragment::MaxSize){
+                  // Common case - one packet in X direction
+                  int size = xend-xstart;
+#ifdef MANTA_SSE
+                  __m128i vec_x = _mm_add_epi32(_mm_set1_epi32(xstart), 
vec_cascade);
+                  for(int i=0;i<size;i+=4){
+                      // This will spill over by up to 3 pixels
+                      _mm_store_si128((__m128i*)&frag.pixel[0][i], vec_x);
+                      vec_x = _mm_add_epi32(vec_x, vec_4);
+                  }
 #else
-          for(int i=0;i<size;i++)
-            frag.pixel[0][i] = i+xstart;
+                  for(int i=0;i<size;i++)
+                      frag.pixel[0][i] = i+xstart;
 #endif
-          frag.setSize(size);
-          for(int y = ystart; y<yend; y++){
+                  frag.setSize(size);
+                  for(int y = ystart; y<yend; y++){
 #ifdef MANTA_SSE
-            int e = (fsize+3)&(~3);
-            __m128i vec_y = _mm_set1_epi32(y);
-            for(int i=0;i<e;i+=4)
-              _mm_store_si128((__m128i*)&frag.pixel[1][i], vec_y);
+                      int e = (fsize+3)&(~3);
+                      __m128i vec_y = _mm_set1_epi32(y);
+                      for(int i=0;i<e;i+=4)
+                          _mm_store_si128((__m128i*)&frag.pixel[1][i], 
vec_y);
 #else
-            for(int i=0;i<fsize;i++)
-              frag.pixel[1][i] = y;
+                      for(int i=0;i<fsize;i++)
+                          frag.pixel[1][i] = y;
 #endif
-            context.pixelSampler->renderFragment(context, frag);
-            image->set(frag);
-          }
-        } else {
-          // General case (multiple packets in X direction)
-          for(int y = ystart; y<yend; y++){
-#ifdef MANTA_SSE
-            int e = (fsize+3)&(~3);
-            __m128i vec_y = _mm_set1_epi32(y);
-            for(int i=0;i<e;i+=4)
-              _mm_store_si128((__m128i*)&frag.pixel[1][i], vec_y);
+                      context.pixelSampler->renderFragment(context, frag);
+                      image->set(frag);
+                  }
+              } else {
+                  // General case (multiple packets in X direction)
+                  for(int y = ystart; y<yend; y++){
+#ifdef MANTA_SSE
+                      int e = (fsize+3)&(~3);
+                      __m128i vec_y = _mm_set1_epi32(y);
+                      for(int i=0;i<e;i+=4)
+                          _mm_store_si128((__m128i*)&frag.pixel[1][i], 
vec_y);
 #else
-            for(int i=0;i<fsize;i++)
-              frag.pixel[1][i] = y;
+                      for(int i=0;i<fsize;i++)
+                          frag.pixel[1][i] = y;
 #endif
-            for(int x = xstart; x<xend; x+= Fragment::MaxSize){
-              // This catches cases where xend-xstart is larger than
-              // Fragment::MaxSize.
-              int xnarf = x+Fragment::MaxSize;
-              if (xnarf > xend) xnarf = xend;
-              int size = xnarf-x;
-#ifdef MANTA_SSE
-              __m128i vec_x = _mm_add_epi32(_mm_set1_epi32(x), vec_cascade);
-              for(int i=0;i<size;i+=4){
-                // This will spill over by up to 3 pixels
-                _mm_store_si128((__m128i*)&frag.pixel[0][i], vec_x);
-                vec_x = _mm_add_epi32(vec_x, vec_4);
-              }
+                      for(int x = xstart; x<xend; x+= Fragment::MaxSize){
+                          // This catches cases where xend-xstart is larger 
than
+                          // Fragment::MaxSize.
+                          int xnarf = x+Fragment::MaxSize;
+                          if (xnarf > xend) xnarf = xend;
+                          int size = xnarf-x;
+#ifdef MANTA_SSE
+                          __m128i vec_x = _mm_add_epi32(_mm_set1_epi32(x), 
vec_cascade);
+                          for(int i=0;i<size;i+=4){
+                              // This will spill over by up to 3 pixels
+                              _mm_store_si128((__m128i*)&frag.pixel[0][i], 
vec_x);
+                              vec_x = _mm_add_epi32(vec_x, vec_4);
+                          }
 #else
-              for(int i=0;i<size;i++)
-                frag.pixel[0][i] = i+x;
+                          for(int i=0;i<size;i++)
+                              frag.pixel[0][i] = i+x;
 #endif
-              frag.setSize(size);
-              context.pixelSampler->renderFragment(context, frag);
-              image->set(frag);
-            }
+                          frag.setSize(size);
+                          context.pixelSampler->renderFragment(context, 
frag);
+                          image->set(frag);
+                      }
+                  }
+              }
           }
-        }
       }
+      break;
+      case Fragment::SquareShape:
+      {
+          Fragment frag(Fragment::SquareShape, Fragment::ConstantEye);
+
+          // Square Shaped fragments of about RayPacket::MaxSize each
+          static const int sqrt_size = 
static_cast<int>(sqrt(RayPacket::MaxSize));
+          static const int full_size = sqrt_size * sqrt_size;
+
+          for(int eye = 0; eye < numEyes; eye++){
+
+              for(int i=0;i<full_size;i++)
+                  frag.whichEye[i] = eye;
+
+              for (int y = ystart; y < yend; y += sqrt_size) {
+                  for (int x = xstart; x < xend; x += sqrt_size) {
+
+                      int j_end = SCIRun::Min(yend - y, sqrt_size);
+                      int i_end = SCIRun::Min(xend - x, sqrt_size);
+
+                      for (int j = 0; j < j_end; ++j) {
+                          for (int i = 0; i < i_end; ++i) {
+                              frag.pixel[0][j*i_end + i] = x + i;
+                              frag.pixel[1][j*i_end + i] = y + j;
+                          }
+                      }
+                      frag.setSize(j_end * i_end);
+                      context.pixelSampler->renderFragment(context, frag);
+
+                      image->set(frag);
+                  }
+              }
+          }
+      }
+      break;
+      default:
+          break;
+      }
+
     }
   }
   // This can potentially happen before the other procesors are finished

Modified: trunk/Engine/ImageTraversers/TiledImageTraverser.h
==============================================================================
--- trunk/Engine/ImageTraversers/TiledImageTraverser.h  (original)
+++ trunk/Engine/ImageTraversers/TiledImageTraverser.h  Thu Aug 10 11:11:30 
2006
@@ -31,6 +31,7 @@
 */
 
 #include <Interface/ImageTraverser.h>
+#include <Interface/Fragment.h>
 #include <sgi_stl_warnings_off.h>
 #include <string>
 #include <vector>
@@ -52,6 +53,8 @@
   private:
     TiledImageTraverser(const TiledImageTraverser&);
     TiledImageTraverser& operator=(const TiledImageTraverser&);
+
+      Fragment::FragmentShape shape;
 
     int xtilesize;
     int ytilesize;

Modified: trunk/Engine/PixelSamplers/FastSampler.cc
==============================================================================
--- trunk/Engine/PixelSamplers/FastSampler.cc   (original)
+++ trunk/Engine/PixelSamplers/FastSampler.cc   Thu Aug 10 11:11:30 2006
@@ -67,7 +67,7 @@
     RayPacket rays(raydata, RayPacket::UnknownShape, 0, size, depth, flags);
 
     // Check to see if the fragment is consecutive in x.
-    if(fragment.getFlag(Fragment::ConsecutiveX|Fragment::ConstantEye) == 
Fragment::ConsecutiveX|Fragment::ConstantEye){
+    if(fragment.getFlag(Fragment::ConsecutiveX|Fragment::ConstantEye)){
 
       // If so place each pixel in the ray packet relative to the first
       // fragment.

Modified: trunk/Engine/PixelSamplers/SingleSampler.cc
==============================================================================
--- trunk/Engine/PixelSamplers/SingleSampler.cc (original)
+++ trunk/Engine/PixelSamplers/SingleSampler.cc Thu Aug 10 11:11:30 2006
@@ -68,7 +68,7 @@
     RayPacket rays(raydata, RayPacket::UnknownShape, 0, size, depth, flags);
 
     // Check to see if the fragment is consecutive in x.
-    if(fragment.getFlag(Fragment::ConsecutiveX|Fragment::ConstantEye) == 
Fragment::ConsecutiveX|Fragment::ConstantEye){
+    if(fragment.getFlag(Fragment::ConsecutiveX|Fragment::ConstantEye)){
 
       // If so place each pixel in the ray packet relative to the first
       // fragment.

Modified: trunk/Image/SimpleImage.h
==============================================================================
--- trunk/Image/SimpleImage.h   (original)
+++ trunk/Image/SimpleImage.h   Thu Aug 10 11:11:30 2006
@@ -45,7 +45,7 @@
     SimpleImage(bool stereo, int xres, int yres);
     virtual ~SimpleImage();
     static Image* create(const std::vector<std::string>& args, bool stereo,
-                        int xres, int yres);
+                         int xres, int yres);
     void set(const Fragment& fragment);
     void get(Fragment& fragment) const;
 
@@ -66,10 +66,10 @@
   {
     delete[] data;
   }
-  
+
   template<class Pixel>
-  Image* SimpleImage<Pixel>::create(const std::vector<std::string>& args, 
-                                   bool stereo, int xres, int yres)
+  Image* SimpleImage<Pixel>::create(const std::vector<std::string>& args,
+                                    bool stereo, int xres, int yres)
   {
     if(args.size() != 0)
       throw SCIRun::IllegalValue<std::string>
@@ -101,7 +101,7 @@
       eyeStart[1] = eyeStart[0]+yres;
       eyeStart[1][0] = eyeStart[0][0]+xpad*yres;
       for(int i=1;i<yres;i++)
-       eyeStart[1][i] = eyeStart[1][i-1]+xpad;
+        eyeStart[1][i] = eyeStart[1][i-1]+xpad;
     } else {
       eyeStart[1] = 0;
     }
@@ -110,12 +110,11 @@
   template<class Pixel>
   void SimpleImage<Pixel>::set(const Fragment& fragment)
   {
-    if(fragment.getFlag(Fragment::ConsecutiveX|Fragment::ConstantEye) ==
-       Fragment::ConsecutiveX|Fragment::ConstantEye){
+    if(fragment.getFlag(Fragment::ConsecutiveX|Fragment::ConstantEye)){
       int b = fragment.begin();
       Pixel* pix = 
eyeStart[fragment.getWhichEye(b)][fragment.getY(b)]+fragment.getX(b);
       for(int i=fragment.begin(); i< fragment.end();i++)
-       convertToPixel(*pix++, fragment.getColor(i).convertRGB());
+        convertToPixel(*pix++, fragment.getColor(i).convertRGB());
     } else {
       for(int i=fragment.begin();i<fragment.end();i++){
         
convertToPixel(eyeStart[fragment.getWhichEye(i)][fragment.getY(i)][fragment.getX(i)],
 fragment.getColor(i).convertRGB());
@@ -138,8 +137,7 @@
   template<class Pixel>
   void SimpleImage<Pixel>::get(Fragment& fragment) const
   {
-    if(fragment.getFlag(Fragment::ConsecutiveX|Fragment::ConstantEye) ==
-       Fragment::ConsecutiveX|Fragment::ConstantEye){
+    if(fragment.getFlag(Fragment::ConsecutiveX|Fragment::ConstantEye)){
       int b = fragment.begin();
       Pixel* pix = 
eyeStart[fragment.getWhichEye(b)][fragment.getY(b)]+fragment.getX(b);
       for(int i=fragment.begin(); i < fragment.end();i++) {

Modified: trunk/Image/SimpleImage_special.cc
==============================================================================
--- trunk/Image/SimpleImage_special.cc  (original)
+++ trunk/Image/SimpleImage_special.cc  Thu Aug 10 11:11:30 2006
@@ -9,8 +9,7 @@
 template<>
 void SimpleImage<ARGB8Pixel>::set(const Fragment& fragment)
 {
-  if(fragment.getFlag(Fragment::ConsecutiveX|Fragment::ConstantEye) ==
-     Fragment::ConsecutiveX|Fragment::ConstantEye){
+  if(fragment.getFlag(Fragment::ConsecutiveX|Fragment::ConstantEye)){
     int b = fragment.begin();
     ARGB8Pixel* pix = 
eyeStart[fragment.getWhichEye(b)][fragment.getY(b)]+fragment.getX(b);
 #if MANTA_SSE
@@ -56,8 +55,7 @@
 template<>
 void SimpleImage<BGRA8Pixel>::set(const Fragment& fragment)
 {
-  if(fragment.getFlag(Fragment::ConsecutiveX|Fragment::ConstantEye) ==
-     Fragment::ConsecutiveX|Fragment::ConstantEye){
+  if(fragment.getFlag(Fragment::ConsecutiveX|Fragment::ConstantEye)){
     int b = fragment.begin();
     BGRA8Pixel* pix = 
eyeStart[fragment.getWhichEye(b)][fragment.getY(b)]+fragment.getX(b);
 #if MANTA_SSE
@@ -120,8 +118,7 @@
 template<>
 void SimpleImage<RGBA8Pixel>::set(const Fragment& fragment)
 {
-  if(fragment.getFlag(Fragment::ConsecutiveX|Fragment::ConstantEye) ==
-     Fragment::ConsecutiveX|Fragment::ConstantEye){
+    if(fragment.getFlag(Fragment::ConsecutiveX|Fragment::ConstantEye)) {
     int b = fragment.begin();
     RGBA8Pixel* pix = 
eyeStart[fragment.getWhichEye(b)][fragment.getY(b)]+fragment.getX(b);
 #if MANTA_SSE
@@ -184,8 +181,7 @@
 template<>
 void SimpleImage<RGBAfloatPixel>::set(const Fragment& fragment)
 {
-  if(fragment.getFlag(Fragment::ConsecutiveX|Fragment::ConstantEye) ==
-     Fragment::ConsecutiveX|Fragment::ConstantEye){
+  if(fragment.getFlag(Fragment::ConsecutiveX|Fragment::ConstantEye)){
     int b = fragment.begin();
     RGBAfloatPixel* pix = 
eyeStart[fragment.getWhichEye(b)][fragment.getY(b)]+fragment.getX(b);
 #if MANTA_SSE
@@ -209,7 +205,7 @@
         // I found this method to be slightly faster and easier to use
         // than the swizzle4 code previously found in the repository.
         _MM_TRANSPOSE4_PS(r, g, b, a);
-        
+
         // Copy data over
         _mm_stream_ps(fpix,    r);
         _mm_stream_ps(fpix+4,  g);

---

• [MANTA] r1163 - in trunk: Engine/ImageTraversers Engine/PixelSamplers Image, boulos, 08/10/2006

---

Archive powered by MHonArc 2.6.16.