clang-format stuff without sorting includes

Author: Chillee

LectureQuizzes/1_30.cu

@@ -1,45 +1,45 @@
 #include <stdio.h>
 
-__global__ void cube(float * d_out, float * d_in){
-	// Todo: Fill in this function
+__global__ void cube(float *d_out, float *d_in) {
+  // Todo: Fill in this function
 }
 
-int main(int argc, char ** argv) {
-	const int ARRAY_SIZE = 64;
-	const int ARRAY_BYTES = ARRAY_SIZE * sizeof(float);
+int main(int argc, char **argv) {
+  const int ARRAY_SIZE = 64;
+  const int ARRAY_BYTES = ARRAY_SIZE * sizeof(float);
 
-	// generate the input array on the host
-	float h_in[ARRAY_SIZE];
-	for (int i = 0; i < ARRAY_SIZE; i++) {
-		h_in[i] = float(i);
-	}
-	float h_out[ARRAY_SIZE];
+  // generate the input array on the host
+  float h_in[ARRAY_SIZE];
+  for (int i = 0; i < ARRAY_SIZE; i++) {
+    h_in[i] = float(i);
+  }
+  float h_out[ARRAY_SIZE];
 
-	// declare GPU memory pointers
-	float * d_in;
-	float * d_out;
+  // declare GPU memory pointers
+  float *d_in;
+  float *d_out;
 
-	// allocate GPU memory
-	cudaMalloc((void**) &d_in, ARRAY_BYTES);
-	cudaMalloc((void**) &d_out, ARRAY_BYTES);
+  // allocate GPU memory
+  cudaMalloc((void **)&d_in, ARRAY_BYTES);
+  cudaMalloc((void **)&d_out, ARRAY_BYTES);
 
-	// transfer the array to the GPU
-	cudaMemcpy(d_in, h_in, ARRAY_BYTES, cudaMemcpyHostToDevice);
+  // transfer the array to the GPU
+  cudaMemcpy(d_in, h_in, ARRAY_BYTES, cudaMemcpyHostToDevice);
 
-	// launch the kernel
-	cube<<<1, ARRAY_SIZE>>>(d_out, d_in);
+  // launch the kernel
+  cube<<<1, ARRAY_SIZE>>>(d_out, d_in);
 
-	// copy back the result array to the CPU
-	cudaMemcpy(h_out, d_out, ARRAY_BYTES, cudaMemcpyDeviceToHost);
+  // copy back the result array to the CPU
+  cudaMemcpy(h_out, d_out, ARRAY_BYTES, cudaMemcpyDeviceToHost);
 
-	// print out the resulting array
-	for (int i =0; i < ARRAY_SIZE; i++) {
-		printf("%f", h_out[i]);
-		printf(((i % 4) != 3) ? "\t" : "\n");
-	}
+  // print out the resulting array
+  for (int i = 0; i < ARRAY_SIZE; i++) {
+    printf("%f", h_out[i]);
+    printf(((i % 4) != 3) ? "\t" : "\n");
+  }
 
-	cudaFree(d_in);
-	cudaFree(d_out);
+  cudaFree(d_in);
+  cudaFree(d_out);
 
-	return 0;
+  return 0;
 }

assignments/HW1/HW1.cpp

@@ -9,21 +9,21 @@
 cv::Mat imageRGBA;
 cv::Mat imageGrey;
 
-uchar4        *d_rgbaImage__;
+uchar4 *d_rgbaImage__;
 unsigned char *d_greyImage__;
 
 size_t numRows() { return imageRGBA.rows; }
 size_t numCols() { return imageRGBA.cols; }
 
-//return types are void since any internal error will be handled by quitting
-//no point in returning error codes...
-//returns a pointer to an RGBA version of the input image
-//and a pointer to the single channel grey-scale output
-//on both the host and device
+// return types are void since any internal error will be handled by quitting
+// no point in returning error codes...
+// returns a pointer to an RGBA version of the input image
+// and a pointer to the single channel grey-scale output
+// on both the host and device
 void preProcess(uchar4 **inputImage, unsigned char **greyImage,
                 uchar4 **d_rgbaImage, unsigned char **d_greyImage,
                 const std::string &filename) {
-  //make sure the context initializes ok
+  // make sure the context initializes ok
   checkCudaErrors(cudaFree(0));
 
   cv::Mat image;
@@ -35,50 +35,53 @@ void preProcess(uchar4 **inputImage, unsigned char **greyImage,
 
   cv::cvtColor(image, imageRGBA, CV_BGR2RGBA);
 
-  //allocate memory for the output
+  // allocate memory for the output
   imageGrey.create(image.rows, image.cols, CV_8UC1);
 
-  //This shouldn't ever happen given the way the images are created
-  //at least based upon my limited understanding of OpenCV, but better to check
+  // This shouldn't ever happen given the way the images are created
+  // at least based upon my limited understanding of OpenCV, but better to check
   if (!imageRGBA.isContinuous() || !imageGrey.isContinuous()) {
     std::cerr << "Images aren't continuous!! Exiting." << std::endl;
     exit(1);
   }
 
   *inputImage = (uchar4 *)imageRGBA.ptr<unsigned char>(0);
-  *greyImage  = imageGrey.ptr<unsigned char>(0);
+  *greyImage = imageGrey.ptr<unsigned char>(0);
 
   const size_t numPixels = numRows() * numCols();
-  //allocate memory on the device for both input and output
+  // allocate memory on the device for both input and output
   checkCudaErrors(cudaMalloc(d_rgbaImage, sizeof(uchar4) * numPixels));
   checkCudaErrors(cudaMalloc(d_greyImage, sizeof(unsigned char) * numPixels));
-  checkCudaErrors(cudaMemset(*d_greyImage, 0, numPixels * sizeof(unsigned char))); //make sure no memory is left laying around
+  checkCudaErrors(cudaMemset(
+      *d_greyImage, 0,
+      numPixels *
+          sizeof(unsigned char))); // make sure no memory is left laying around
 
-  //copy input array to the GPU
-  checkCudaErrors(cudaMemcpy(*d_rgbaImage, *inputImage, sizeof(uchar4) * numPixels, cudaMemcpyHostToDevice));
+  // copy input array to the GPU
+  checkCudaErrors(cudaMemcpy(*d_rgbaImage, *inputImage,
+                             sizeof(uchar4) * numPixels,
+                             cudaMemcpyHostToDevice));
 
   d_rgbaImage__ = *d_rgbaImage;
   d_greyImage__ = *d_greyImage;
 }
 
-void postProcess(const std::string& output_file, unsigned char* data_ptr) {
-  cv::Mat output(numRows(), numCols(), CV_8UC1, (void*)data_ptr);
+void postProcess(const std::string &output_file, unsigned char *data_ptr) {
+  cv::Mat output(numRows(), numCols(), CV_8UC1, (void *)data_ptr);
 
-  //output the image
+  // output the image
   cv::imwrite(output_file.c_str(), output);
 }
 
-void cleanup()
-{
-  //cleanup
+void cleanup() {
+  // cleanup
   cudaFree(d_rgbaImage__);
   cudaFree(d_greyImage__);
 }
 
-void generateReferenceImage(std::string input_filename, std::string output_filename)
-{
+void generateReferenceImage(std::string input_filename,
+                            std::string output_filename) {
   cv::Mat reference = cv::imread(input_filename, CV_LOAD_IMAGE_GRAYSCALE);
 
   cv::imwrite(output_filename, reference);
-
 }

assignments/HW1/compare.cpp

@@ -4,37 +4,39 @@
 
 #include "utils.h"
 
-void compareImages(std::string reference_filename, std::string test_filename, 
-                   bool useEpsCheck, double perPixelError, double globalError)
-{
+void compareImages(std::string reference_filename, std::string test_filename,
+                   bool useEpsCheck, double perPixelError, double globalError) {
   cv::Mat reference = cv::imread(reference_filename, -1);
   cv::Mat test = cv::imread(test_filename, -1);
 
   cv::Mat diff = abs(reference - test);
 
-  cv::Mat diffSingleChannel = diff.reshape(1, 0); //convert to 1 channel, same # rows
+  cv::Mat diffSingleChannel =
+      diff.reshape(1, 0); // convert to 1 channel, same # rows
 
   double minVal, maxVal;
 
-  cv::minMaxLoc(diffSingleChannel, &minVal, &maxVal, NULL, NULL); //NULL because we don't care about location
+  cv::minMaxLoc(diffSingleChannel, &minVal, &maxVal, NULL,
+                NULL); // NULL because we don't care about location
 
-  //now perform transform so that we bump values to the full range
+  // now perform transform so that we bump values to the full range
 
   diffSingleChannel = (diffSingleChannel - minVal) * (255. / (maxVal - minVal));
 
   diff = diffSingleChannel.reshape(reference.channels(), 0);
 
   cv::imwrite("HW1_differenceImage.png", diff);
-  //OK, now we can start comparing values...
+  // OK, now we can start comparing values...
   unsigned char *referencePtr = reference.ptr<unsigned char>(0);
   unsigned char *testPtr = test.ptr<unsigned char>(0);
 
   if (useEpsCheck) {
-    checkResultsEps(referencePtr, testPtr, reference.rows * reference.cols * reference.channels(), perPixelError, globalError);
-  }
-  else
-  {
-    checkResultsExact(referencePtr, testPtr, reference.rows * reference.cols * reference.channels());
+    checkResultsEps(referencePtr, testPtr,
+                    reference.rows * reference.cols * reference.channels(),
+                    perPixelError, globalError);
+  } else {
+    checkResultsExact(referencePtr, testPtr,
+                      reference.rows * reference.cols * reference.channels());
   }
 
   std::cout << "PASS" << std::endl;

assignments/HW1/compare.h

@@ -1,7 +1,7 @@
 #ifndef COMPARE_H__
 #define COMPARE_H__
 
-void compareImages(std::string reference_filename, std::string test_filename, 
+void compareImages(std::string reference_filename, std::string test_filename,
                    bool useEpsCheck, double perPixelError, double globalError);
 
 #endif

assignments/HW1/main.cpp

@@ -1,4 +1,4 @@
-//Udacity HW1 Solution
+// Udacity HW1 Solution
 
 #include <iostream>
 #include "timer.h"
@@ -8,83 +8,90 @@
 #include "reference_calc.h"
 #include "compare.h"
 
-void your_rgba_to_greyscale(const uchar4 * const h_rgbaImage, 
-                            uchar4 * const d_rgbaImage,
-                            unsigned char* const d_greyImage, 
-                            size_t numRows, size_t numCols);
+void your_rgba_to_greyscale(const uchar4 *const h_rgbaImage,
+                            uchar4 *const d_rgbaImage,
+                            unsigned char *const d_greyImage, size_t numRows,
+                            size_t numCols);
 
-//include the definitions of the above functions for this homework
+// include the definitions of the above functions for this homework
 #include "HW1.cpp"
 
 int main(int argc, char **argv) {
-  uchar4        *h_rgbaImage, *d_rgbaImage;
+  uchar4 *h_rgbaImage, *d_rgbaImage;
   unsigned char *h_greyImage, *d_greyImage;
 
   std::string input_file;
   std::string output_file;
   std::string reference_file;
   double perPixelError = 0.0;
-  double globalError   = 0.0;
+  double globalError = 0.0;
   bool useEpsCheck = false;
-  switch (argc)
-  {
-	case 2:
-	  input_file = std::string(argv[1]);
-	  output_file = "HW1_output.png";
-	  reference_file = "HW1_reference.png";
-	  break;
-	case 3:
-	  input_file  = std::string(argv[1]);
-      output_file = std::string(argv[2]);
-	  reference_file = "HW1_reference.png";
-	  break;
-	case 4:
-	  input_file  = std::string(argv[1]);
-      output_file = std::string(argv[2]);
-	  reference_file = std::string(argv[3]);
-	  break;
-	case 6:
-	  useEpsCheck=true;
-	  input_file  = std::string(argv[1]);
-	  output_file = std::string(argv[2]);
-	  reference_file = std::string(argv[3]);
-	  perPixelError = atof(argv[4]);
-      globalError   = atof(argv[5]);
-	  break;
-	default:
-      std::cerr << "Usage: ./HW1 input_file [output_filename] [reference_filename] [perPixelError] [globalError]" << std::endl;
-      exit(1);
+  switch (argc) {
+  case 2:
+    input_file = std::string(argv[1]);
+    output_file = "HW1_output.png";
+    reference_file = "HW1_reference.png";
+    break;
+  case 3:
+    input_file = std::string(argv[1]);
+    output_file = std::string(argv[2]);
+    reference_file = "HW1_reference.png";
+    break;
+  case 4:
+    input_file = std::string(argv[1]);
+    output_file = std::string(argv[2]);
+    reference_file = std::string(argv[3]);
+    break;
+  case 6:
+    useEpsCheck = true;
+    input_file = std::string(argv[1]);
+    output_file = std::string(argv[2]);
+    reference_file = std::string(argv[3]);
+    perPixelError = atof(argv[4]);
+    globalError = atof(argv[5]);
+    break;
+  default:
+    std::cerr << "Usage: ./HW1 input_file [output_filename] "
+                 "[reference_filename] [perPixelError] [globalError]"
+              << std::endl;
+    exit(1);
   }
-  //load the image and give us our input and output pointers
-  preProcess(&h_rgbaImage, &h_greyImage, &d_rgbaImage, &d_greyImage, input_file);
+  // load the image and give us our input and output pointers
+  preProcess(&h_rgbaImage, &h_greyImage, &d_rgbaImage, &d_greyImage,
+             input_file);
 
   GpuTimer timer;
   timer.Start();
-  //call the students' code
-  your_rgba_to_greyscale(h_rgbaImage, d_rgbaImage, d_greyImage, numRows(), numCols());
+  // call the students' code
+  your_rgba_to_greyscale(h_rgbaImage, d_rgbaImage, d_greyImage, numRows(),
+                         numCols());
   timer.Stop();
-  cudaDeviceSynchronize(); checkCudaErrors(cudaGetLastError());
+  cudaDeviceSynchronize();
+  checkCudaErrors(cudaGetLastError());
 
   int err = printf("Your code ran in: %f msecs.\n", timer.Elapsed());
 
   if (err < 0) {
-    //Couldn't print! Probably the student closed stdout - bad news
-    std::cerr << "Couldn't print timing information! STDOUT Closed!" << std::endl;
+    // Couldn't print! Probably the student closed stdout - bad news
+    std::cerr << "Couldn't print timing information! STDOUT Closed!"
+              << std::endl;
     exit(1);
   }
 
-  size_t numPixels = numRows()*numCols();
-  checkCudaErrors(cudaMemcpy(h_greyImage, d_greyImage, sizeof(unsigned char) * numPixels, cudaMemcpyDeviceToHost));
+  size_t numPixels = numRows() * numCols();
+  checkCudaErrors(cudaMemcpy(h_greyImage, d_greyImage,
+                             sizeof(unsigned char) * numPixels,
+                             cudaMemcpyDeviceToHost));
 
-  //check results and output the grey image
+  // check results and output the grey image
   postProcess(output_file, h_greyImage);
 
   referenceCalculation(h_rgbaImage, h_greyImage, numRows(), numCols());
 
   postProcess(reference_file, h_greyImage);
 
-  //generateReferenceImage(input_file, reference_file);
-  compareImages(reference_file, output_file, useEpsCheck, perPixelError, 
+  // generateReferenceImage(input_file, reference_file);
+  compareImages(reference_file, output_file, useEpsCheck, perPixelError,
                 globalError);
 
   cleanup();