Pages: [1]   Go Down
Print
Author Topic: svolgimento compito 17 Ottobre  (Read 825 times)
0 Members e 1 Utente non registrato stanno visualizzando questa discussione.
Pandemia000
Forumista Eroico
*****
Offline Offline

Gender: Male
Posts: 1.714


Γνῶθι Σεαυτόν


« on: 17-10-2011, 17:38:57 »

Premetto che potrei aver frainteso la spiegazione fatta oggi sul punto bonus ( non c'è stato il tempo di prendere appunti e dalle 2 ad ora mi sono occupato di altre cose), in ogni caso ecco il codice pronto per essere corretto.
Code:
#include <stdio.h>
#include "pamalign.h"
#include <cuda_runtime_api.h>
#include <vector_types.h>
#include "makelines.h"

 __constant__ size_t pitch;
  __constant__  uint maxval;
  __constant__  float T;


__device__ ushort2* getElement (const ushort2 *src, const uint x, const uint y)
     {
return ((ushort2*) ((char*)src+y*pitch)+x);     
     }

__global__ void esame(ushort2 *data, const float4 *rette, const int nlines, const size_t width, const size_t height)
  {
     uint x = blockDim.x*blockIdx.x + threadIdx.x;
     uint y = blockDim.y*blockIdx.y + threadIdx.y;
if ((x >= width) || (y >= height))
  return;
     
float minv=256;
for( int i=0; i< nlines;i++)
{    
     float4 ret=rette[i];
     if( (abs( x * ret.x + y * ret.y +  ret.z)) < T)
     {
float current=fmax(0, (maxval* (abs(x *ret.x + ret.y* y+ ret.z)-T)));
if( current< minv)
   minv=current;
     }
}
if (minv!= 256 )
   *getElement(data,x,y)=make_ushort2(minv,minv);
else
         *getElement(data,x,y)=make_ushort2(maxval,maxval);
   }
     
     
int main(int argc, char **argv)
      {
imgInfo img; // image
img.width=1600;
img.height=1600;
img.depth=8;             
        img.maxval=255; 
img.channels=2;     
int res=alloc_img(&img);
        if(res==1) {  return 1;}
float T=0.5f;
size_t hPitch = img.data_size/img.height;
size_t srcPitch;
ushort2 *dataSrc;
cudaMallocPitch(&dataSrc,&srcPitch,hPitch,img.height); //allocating source
cudaMemcpyToSymbol("pitch", &srcPitch, sizeof(srcPitch), 0, cudaMemcpyHostToDevice);
cudaMemcpyToSymbol("maxval",&img.maxval,sizeof(img.maxval),0,cudaMemcpyHostToDevice);
cudaMemcpyToSymbol("T",&(T),sizeof(float),0,cudaMemcpyHostToDevice);

cudaMemcpy2D(dataSrc, srcPitch, img.data, hPitch, hPitch, img.height, cudaMemcpyHostToDevice);


float4 *lines,*rette ;
int nlines=128;
make_lines(&lines, nlines , (img.height) /3, (img.width)/2);

cudaMalloc(&rette,nlines*sizeof(*rette));  //allocating device points vector       
        cudaMemcpy(rette,lines,nlines*sizeof(*rette),cudaMemcpyHostToDevice); 
   
dim3 blockSize, gridSize;
blockSize.x = 16;
blockSize.y = 16;

gridSize.x = ceil((float)img.width/blockSize.x);
gridSize.y = ceil((float)img.height/blockSize.y);

cudaEvent_t gpu_start, gpu_stop;
        float gpu_runtime;
        cudaEventCreate(&gpu_start);
        cudaEventCreate(&gpu_stop);
        cudaEventRecord(gpu_start, 0);

esame<<<gridSize, blockSize >>>(dataSrc,rette, nlines, img.width, img.height);

cudaThreadSynchronize();
         
cudaEventRecord(gpu_stop, 0);
        cudaEventSynchronize(gpu_stop);
        cudaEventElapsedTime(&gpu_runtime, gpu_start, gpu_stop);     
        cudaEventDestroy(gpu_start);
        cudaEventDestroy(gpu_stop);  
 

cudaMemcpy2D(img.data, hPitch, dataSrc, srcPitch, hPitch, img.height, cudaMemcpyDeviceToHost);

cudaFree(dataSrc);

save_pam("output.pam", &img);
printf("Image saved: %u channels, %ux%ux%u\n",img.channels, img.width, img.height, img.depth);
        printf("Elapsed Time: %gms\n", gpu_runtime);


}
 
Logged

La disumanità del computer sta nel fatto che, una volta programmato e messo in funzione, si comporta in maniera perfettamente onesta. (Isaac Asimov)
Pages: [1]   Go Up
Print
Jump to: