void FlatVolume<T>::AllocateVolume() { INFO("Allocating the volume : " + ITS(NXYZ) + CATS(" voxels") + CATS(" - ") + ITS(volumeSize) + CATS(" Bytes")); // Volume allocation this->ptrVolumeData = (T*) malloc (volumeSize); INFO("The FLAT volume has been successfully allocated in 1D array"); }
void FlatVolume<T>::FreeVolume() { INFO("Freeing a volume data block of size: " + CATS("[") + ITS(NX) + CATS("] X [") + ITS(NY) + CATS("] X [") + ITS(NZ) + CATS("]") + CATS(" - ") + ITS(volumeSize) + " Bytes"); // Release volume data memory block free(this->ptrVolumeData); INFO("Freeing volume data has been done successfully"); }
// Constructor template <class T> Image<T>::Image (const int NX, const int NY) : NX(NX), NY(NY) { INFO("Creating a 2D Image object of size : " + CATS("[") + ITS(NX) + CATS("] X [") + ITS(NY) + CATS("]")); // Total number of pixels in the image this->NXY = NX * NY; // Image size in Bytes ImageSize = sizeof(T) * this->NXY; // Allocating the Image data memory block Image::AllocateImage(); }
// Constructor template <class T> FlatVolume<T>::FlatVolume (const int NX, const int NY, const int NZ) : NX(NX), NY(NY), NZ(NZ) { INFO("Creating a FLAT volume object of size : " + CATS("[") + ITS(NX) + CATS("] X [") + ITS(NY) + CATS("] X [") + ITS(NZ) + CATS("]")); // Total number of voxels in the volume NXYZ = NX * NY * NZ; // Volume size in Bytes volumeSize = sizeof(T) * NXYZ; FlatVolume::AllocateVolume(); }
void Image<T>::AllocateImage() { INFO("Allocating a 2D Image : " + ITS(this->NXY) + CATS(" pixels") + CATS(" - ") + ITS(this->ImageSize) + CATS(" Bytes")); // 2D Image allocation this->ptrImageData = (T**) malloc (sizeof(T*) * this->NX); for(int j = 0; j < this->NX; j++) { this->ptrImageData[j] = (T*) malloc (sizeof(T) * this->NY); } INFO("The Image has been successfully allocated 3D array"); }
void cuUtils::DisplayKernelProfilingData(char* kernelName, cuProfile* profile) { COUT << TAB; SEP(); COUT << TAB << "Kernel Execution Time @[" << CATS(kernelName) << "]" << ENDL; COUT << TAB << TAB << "@Nano-Seconds (ns) : " << (profile->kernelDuration * (1000 * 1000)) << ENDL; COUT << TAB << TAB << "@Micro-Seconds (us) : " << (profile->kernelDuration * 1000) << ENDL; COUT << TAB << TAB << "@Milli-Seconds (ms) : " << profile->kernelDuration << ENDL; COUT << TAB << TAB << "@Seconds (s) : " << (profile->kernelDuration / (1000)) << ENDL; COUT << TAB; SEP(); }
void ReadVolume(char *prefix) { char imgFile[100]; ifstream inputFileStream; // Reading the header file ReadHeader(prefix, iWidth, iHeight, iDepth); INFO("Volume size: [" + ITS(iWidth) + "X" + ITS(iHeight) + "x" + ITS(iDepth) + "]"); // Adding the ".img" prefix to the dataset path sprintf(imgFile, "%s.img", prefix); INFO("Reading the volume file " + CATS(imgFile)); // Total number of voxels numVoxels = iWidth * iHeight * iDepth; INFO("Number of voxels : " + ITS(numVoxels)); // Allocating the luminance image luminanceImage = new GLubyte [numVoxels]; // Allocating the RGBA image rgbaImage = new GLubyte [numVoxels * 4]; // Reading the volume image (luminance values) inputFileStream.open(imgFile, ios::in); if (inputFileStream.fail()) { INFO("Could not open " + CATS(imgFile)); EXIT(0); } // Read the image byte by byte inputFileStream.read((char *)luminanceImage, numVoxels); // Closing the input volume stream inputFileStream.close(); // Update the volume UpdateVolume(); INFO("The volume has been read successfull and the RGBA one is DONE"); }
void Image<T>::FreeImage() { INFO("Freeing a 3D Image data block of size: " + CATS("[") + ITS(this->NX) + CATS("] X [") + ITS(this->NY) + CATS("]") + CATS(" - ") + ITS(this->ImageSize) + " Bytes"); for(int j = 0; j < this->NY; j++) { // Release Y free(this->ptrImageData[j]); } // Release X free(this->ptrImageData); // Nulling the dangling pointer this->ptrImageData = NULL; INFO("Freeing 2D Image data has been done successfully"); }
void ex_RealArray::DumpNumbers_Single() { INFO("ex_RealArray - Single Precision"); // Create the XL book xlBook = Utils::xl::createBook(); INFO("xlBook created : " + CATS(xlBookName_Single)); SEP(); if(xlBook) { /********************************************************** * 1D Case **********************************************************/ xlSheet = Utils::xl::addSheetToBook("1D", xlBook); if (xlSheet) { INFO("** 1D Case"); size_N = size_X; // Allocation floatArray_1D = MEM_ALLOC_1D(float, size_N); INFO("Array allocation done"); // Filling array (Sequential) Array::fillArray_1D_float(floatArray_1D, size_N, 1); INFO("Filing array done - Sequential"); // Headers xlSheet->writeStr(1, 0, "Seq"); // Filling column with data for (int j = 0; j < size_N; j++) xlSheet->writeNum(j + 2, 0, floatArray_1D[j]); // Filling array (Random) Array::fillArray_1D_float(floatArray_1D, size_N, 0); INFO("Filing array done - Random"); // Headers xlSheet->writeStr(1, 1, "Rnd"); // Filling column with data for (int j = 0; j < size_N; j++) xlSheet->writeNum(j + 2, 1, floatArray_1D[j]); // Freeing memory FREE_MEM_1D(floatArray_1D); INFO("Freeing memory"); } else { INFO("No valid xlSheet was created, EXITTING ..."); EXIT(0); } SEP(); /********************************************************** * 2D Flat Case **********************************************************/ xlSheet = Utils::xl::addSheetToBook("Flat_2D", xlBook); if (xlSheet) { INFO("** 2D Flat Case"); size_N = size_X * size_Y; // Allocation floatArray_2D_flat = MEM_ALLOC_1D(float, size_N); INFO("Array allocation done"); // Filling array (Sequential) Array::fillArray_2D_flat_float(floatArray_2D_flat, size_X, size_Y, 1); INFO("Filing array done - Sequential"); // Headers xlSheet->writeStr(1, 0, "Seq"); // Filling column with data for (int j = 0; j < size_N; j++) xlSheet->writeNum(j + 2, 0, floatArray_2D_flat[j]); // Filling array (Random) Array::fillArray_2D_flat_float(floatArray_2D_flat, size_X, size_Y, 0); INFO("Filing array done - Random"); // Headers xlSheet->writeStr(1, 1, "Rnd"); // Filling column with data for (int j = 0; j < size_N; j++) xlSheet->writeNum(j + 2, 1, floatArray_2D_flat[j]); // Freeing memory FREE_MEM_1D(floatArray_2D_flat); INFO("Freeing memory"); } else {