Adding support for cudaReadModeNormalizedFloat (a texture read mode). See bug 18 (external) for detail. The blocked SDK benchmarks are still not working due to mismatch of texture element layout in memory between real GPU and GPGPU-Sim.

[git-p4: depot-paths = "//depot/gpgpu_sim_research/fermi/distribution/": change = 13933]

3 files changed, 80 insertions, 2 deletions

diff --git a/src/abstract_hardware_model.h b/src/abstract_hardware_model.h
index 766dff1..b6a4111 100644
--- a/src/abstract_hardware_model.h
+++ b/src/abstract_hardware_model.h
@@ -318,6 +318,21 @@ struct textureReference {
 
 #endif
 
+// Struct that record other attributes in the textureReference declaration 
+// - These attributes are passed thru __cudaRegisterTexture()
+struct textureReferenceAttr {
+    const struct textureReference *m_texref; 
+    int m_dim; 
+    enum cudaTextureReadMode m_readmode; 
+    int m_ext; 
+    textureReferenceAttr(const struct textureReference *texref, 
+                         int dim, 
+                         enum cudaTextureReadMode readmode, 
+                         int ext)
+    : m_texref(texref), m_dim(dim), m_readmode(readmode), m_ext(ext) 
+    {  }
+};
+
 class gpgpu_functional_sim_config 
 {
 public:
@@ -364,7 +379,7 @@ public:
     class memory_space *get_surf_memory() { return m_surf_mem; }
 
     void gpgpu_ptx_sim_bindTextureToArray(const struct textureReference* texref, const struct cudaArray* array);
-    void gpgpu_ptx_sim_bindNameToTexture(const char* name, const struct textureReference* texref);
+    void gpgpu_ptx_sim_bindNameToTexture(const char* name, const struct textureReference* texref, int dim, int readmode, int ext);
     const char* gpgpu_ptx_sim_findNamefromTexture(const struct textureReference* texref);
 
     const struct textureReference* get_texref(const std::string &texname) const
@@ -386,6 +401,13 @@ public:
         return t->second;
     }
 
+    const struct textureReferenceAttr* get_texattr( const struct textureReference *texref ) const
+    {
+        std::map<const struct textureReference*, const struct textureReferenceAttr*>::const_iterator t=m_TextureRefToAttribute.find(texref);
+        assert(t != m_TextureRefToAttribute.end());
+        return t->second;
+    }
+
     const gpgpu_functional_sim_config &get_config() const { return m_function_model_config; }
     FILE* get_ptx_inst_debug_file() { return ptx_inst_debug_file; }
 
@@ -402,6 +424,7 @@ protected:
     std::map<std::string, const struct textureReference*> m_NameToTextureRef;
     std::map<const struct textureReference*,const struct cudaArray*> m_TextureRefToCudaArray;
     std::map<const struct textureReference*, const struct textureInfo*> m_TextureRefToTexureInfo;
+    std::map<const struct textureReference*, const struct textureReferenceAttr*> m_TextureRefToAttribute;
 };
 
 struct gpgpu_ptx_sim_kernel_info 
diff --git a/src/cuda-sim/cuda-sim.cc b/src/cuda-sim/cuda-sim.cc
index e6677fa..06fb7d3 100644
--- a/src/cuda-sim/cuda-sim.cc
+++ b/src/cuda-sim/cuda-sim.cc
@@ -93,10 +93,12 @@ void ptx_opcocde_latency_options (option_parser_t opp) {
 
 static address_type get_converge_point(address_type pc);
 
-void gpgpu_t::gpgpu_ptx_sim_bindNameToTexture(const char* name, const struct textureReference* texref)
+void gpgpu_t::gpgpu_ptx_sim_bindNameToTexture(const char* name, const struct textureReference* texref, int dim, int readmode, int ext)
 {
    std::string texname(name);
    m_NameToTextureRef[texname] = texref;
+   const textureReferenceAttr *texAttr = new textureReferenceAttr(texref, dim, (enum cudaTextureReadMode)readmode, ext); 
+   m_TextureRefToAttribute[texref] = texAttr; 
 }
 
 const char* gpgpu_t::gpgpu_ptx_sim_findNamefromTexture(const struct textureReference* texref)
diff --git a/src/cuda-sim/instructions.cc b/src/cuda-sim/instructions.cc
index 237bfd5..65d3af8 100644
--- a/src/cuda-sim/instructions.cc
+++ b/src/cuda-sim/instructions.cc
@@ -3642,6 +3642,50 @@ float tex_linf_sampling(memory_space* mem, unsigned tex_array_base,
    return sample;
 }
 
+float textureNormalizeElementSigned(int element, int bits)
+{
+   if (bits) {
+      int maxN = (1 << bits) - 1; 
+      // removing upper bits 
+      element &= maxN;
+      // normalizing the number to [-1.0,1.0]
+      maxN >>= 1;
+      float output = (float) element / maxN;  
+      if (output < -1.0f) output = -1.0f; 
+      return output; 
+   } else {
+      return 0.0f; 
+   }
+}
+
+float textureNormalizeElementUnsigned(unsigned int element, int bits)
+{
+   if (bits) {
+      unsigned int maxN = (1 << bits) - 1; 
+      // removing upper bits and normalizing the number to [0.0,1.0]
+      return (float)(element & maxN) / maxN;  
+   } else {
+      return 0.0f; 
+   }
+}
+
+void textureNormalizeOutput( const struct cudaChannelFormatDesc& desc, ptx_reg_t& datax, ptx_reg_t& datay, ptx_reg_t& dataz, ptx_reg_t& dataw ) 
+{
+   if (desc.f == cudaChannelFormatKindSigned) {
+      datax.f32 = textureNormalizeElementSigned( datax.s32, desc.x ); 
+      datay.f32 = textureNormalizeElementSigned( datay.s32, desc.y ); 
+      dataz.f32 = textureNormalizeElementSigned( dataz.s32, desc.z ); 
+      dataw.f32 = textureNormalizeElementSigned( dataw.s32, desc.w ); 
+   } else if (desc.f == cudaChannelFormatKindUnsigned) {
+      datax.f32 = textureNormalizeElementUnsigned( datax.u32, desc.x ); 
+      datay.f32 = textureNormalizeElementUnsigned( datay.u32, desc.y ); 
+      dataz.f32 = textureNormalizeElementUnsigned( dataz.u32, desc.z ); 
+      dataw.f32 = textureNormalizeElementUnsigned( dataw.u32, desc.w ); 
+   } else {
+      assert(0 && "Undefined texture read mode: cudaReadModeNormalizedFloat expect integer elements"); 
+   }
+}
+
 void tex_impl( const ptx_instruction *pI, ptx_thread_info *thread ) 
 {
    unsigned dimension = pI->dimension();
@@ -3661,6 +3705,7 @@ void tex_impl( const ptx_instruction *pI, ptx_thread_info *thread )
    const struct textureReference* texref = gpu->get_texref(texname);
    const struct cudaArray* cuArray = gpu->get_texarray(texref); 
    const struct textureInfo* texInfo = gpu->get_texinfo(texref);
+   const struct textureReferenceAttr* texAttr = gpu->get_texattr(texref);
 
    //assume always 2D f32 input
    //access array with src2 coordinates
@@ -3878,6 +3923,14 @@ void tex_impl( const ptx_instruction *pI, ptx_thread_info *thread )
       assert(0);
    }
    thread->m_last_memory_space = tex_space; 
+
+   // normalize output into floating point numbers according to the texture read mode
+   if (texAttr->m_readmode == cudaReadModeNormalizedFloat) {
+      textureNormalizeOutput(cuArray->desc, data1, data2, data3, data4); 
+   } else {
+      assert(texAttr->m_readmode == cudaReadModeElementType); 
+   }
+
    thread->set_vector_operand_values(dst,data1,data2,data3,data4);
 }