diff --git a/OpenMP/linear-algebra/kernels/atax/atax.cu b/OpenMP/linear-algebra/kernels/atax/atax.cu
index 5bfb264..cc6d9cb 100644
--- a/OpenMP/linear-algebra/kernels/atax/atax.cu
+++ b/OpenMP/linear-algebra/kernels/atax/atax.cu
@@ -17,96 +17,97 @@
 	#define M_PI 3.141
 #endif
 
-/* Array initialization. */
-static void init_array(int nx, int ny, DATA_TYPE POLYBENCH_2D(A, NX, NY, nx, ny), DATA_TYPE POLYBENCH_1D(x, NY, ny))
+/**
+ * Initialize the arrays to be used in the computation:
+ * 
+ * - `x` is filled with multiples of `M_PI`;
+ * - `A` is filled with sample data.
+ * 
+ * To be called on the CPU (uses the `__host__` qualifier).
+ */
+__host__ static void init_array(int nx, int ny, DATA_TYPE POLYBENCH_2D(A, NX, NY, nx, ny), DATA_TYPE POLYBENCH_1D(x, NY, ny))
 {
-	int i, j;
-
-	/// Initialize the `x` array with PI and its multiples.
-	for (i = 0; i < ny; i++) {
+	for (int i = 0; i < ny; i++) {
 		x[i] = i * M_PI;
 	}
 
-	/// Initialize the `A` matrix
-	for (i = 0; i < nx; i++) {
-		for (j = 0; j < ny; j++) {
+	for (int i = 0; i < nx; i++) {
+		for (int j = 0; j < ny; j++) {
 			A[i][j] = ((DATA_TYPE)i * (j + 1)) / nx;
 		}
 	}
 }
 
-/* DCE code. Must scan the entire live-out data.
-	 Can be used also to check the correctness of the output. */
-static void print_array(int nx, DATA_TYPE POLYBENCH_1D(y, NX, nx))
+/** 
+ * Print the given array. 
+ * 
+ * Cannot be parallelized, as the elements of the array should be 
+ * 
+ * To be called on the CPU (uses the `__host__` qualifier).
+ */
+__host__ static void print_array(int nx, DATA_TYPE POLYBENCH_1D(y, NX, nx))
 {
 	int i;
 
-	/// Print all numbers in the array sequentially.
-	// Cannot parallelize this: prints have to be sequential to make sense!
 	for (i = 0; i < nx; i++) {
 		fprintf(stderr, DATA_PRINTF_MODIFIER, y[i]);
 	}
 	fprintf(stderr, "\n");
 }
 
-/* Main computational kernel. The whole function will be timed,
-	 including the call and return. */
-static void kernel_atax(int nx, int ny, DATA_TYPE POLYBENCH_2D(A, NX, NY, nx, ny), DATA_TYPE POLYBENCH_1D(x, NY, ny), DATA_TYPE POLYBENCH_1D(y, NY, ny))
-{
-	int i, j;
 
-	for (i = 0; i < _PB_NY; i++)
+/**
+ * Compute ATAX.
+ * 
+ * Parallelizing this is the goal of the assignment.
+ * 
+ * Currently to be called on the CPU (uses the `__host__` qualifier), but we may probably want to change that soon.
+ */
+__host__ static void kernel_atax(int nx, int ny, DATA_TYPE POLYBENCH_2D(A, NX, NY, nx, ny), DATA_TYPE POLYBENCH_1D(x, NY, ny), DATA_TYPE POLYBENCH_1D(y, NY, ny))
+{
+	for (int i = 0; i < _PB_NY; i++) {
 		y[i] = 0;
+	}
 	
-	/// This computes... something? I guess whatever ATAX is?
-	// Now this gives a nice speedup, especially with a lot more threads than the count!
-	// THREAD_COUNT * 4 seems to be the best on my local computer. What's the best for the Jetson Nano?
-	for (i = 0; i < _PB_NX; i++)
-	{
-		/// Every iteration has its own tmp variable
+	for (int i = 0; i < _PB_NX; i++) {
 		DATA_TYPE tmp = 0;
 		
-		for (j = 0; j < _PB_NY; j++) {
-			/// Which gets increased by a bit on every iteration
+		for (int j = 0; j < _PB_NY; j++) {
 			tmp += A[i][j] * x[j];
 		}
 		
-		for (j = 0; j < _PB_NY; j++) {
-			/// Which is later used for to compute ATAX
+		for (int j = 0; j < _PB_NY; j++) {
 			y[j] = y[j] + A[i][j] * tmp;
 		}
 	}
 }
 
-int main(int argc, char **argv)
+/**
+ * The main function of the benchmark, which sets up tooling to measure the time spent computing `kernel_atax`.
+ * 
+ * We should probably avoid editing this.
+ */
+__host__ int main(int argc, char **argv)
 {
-	/* Retrieve problem size. */
 	int nx = NX;
 	int ny = NY;
 
-	/* Variable declaration/allocation. */
 	POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, NX, NY, nx, ny);
 	POLYBENCH_1D_ARRAY_DECL(x, DATA_TYPE, NY, ny);
 	POLYBENCH_1D_ARRAY_DECL(y, DATA_TYPE, NY, ny);
 
-	/* Initialize array(s). */
 	init_array(nx, ny, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(x));
 	
-	/* Start timer. */
 	polybench_start_instruments;
 
-	/* Run kernel. */
 	kernel_atax(nx, ny, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(x), POLYBENCH_ARRAY(y));
 
-	/* Stop and print timer. */
 	polybench_stop_instruments;
 	polybench_print_instruments;
 
-	/* Prevent dead-code elimination. All live-out data must be printed
-		 by the function call in argument. */
+	/* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */
 	polybench_prevent_dce(print_array(nx, POLYBENCH_ARRAY(y)));
 	
-	/* Be clean. */
 	POLYBENCH_FREE_ARRAY(A);
 	POLYBENCH_FREE_ARRAY(x);
 	POLYBENCH_FREE_ARRAY(y);