mtx_x86.c File Reference

#include <chrono>
#include <cstdlib>
#include <iostream>
#include <random>

Go to the source code of this file.

Functions
void	matrix_addition (float *A, float *B, float *C, int matrixSize)
void	initialize_matrix_random (float *matrix, int matrixSize)
void	print_matrix (const char *name, float *matrix, int matrixSize)
int	main ()

Function Documentation

initialize_matrix_random()

void initialize_matrix_random	(	float *	matrix,
		int	matrixSize
	)

Definition at line 8 of file mtx_x86.c.

                                                             {
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_real_distribution<float> distribution(1.0, 100.0);
 
    for (int i = 0; i < matrixSize * matrixSize; ++i) {
        matrix[i] = distribution(gen);
    }
}

References matrixSize.

Referenced by main().

main()

int main

(

void

)

Definition at line 29 of file mtx_x86.c.

           {
    // Matrix dimensions (assuming 4x4 matrices)
    int matrixSize = 8192;
 
    std::chrono::steady_clock::time_point gen_start_time =
        std::chrono::steady_clock::now();
 
    // Allocate memory for matrices A, B, and C
    float *A = new float[matrixSize * matrixSize];
    float *B = new float[matrixSize * matrixSize];
    float *C = new float[matrixSize * matrixSize];
    /*
    float *A = static_cast<float*>(aligned_alloc(16, matrixSize * matrixSize *
    sizeof(float))); float *B = static_cast<float*>(aligned_alloc(16, matrixSize
    * matrixSize * sizeof(float))); float *C =
    static_cast<float*>(aligned_alloc(16, matrixSize * matrixSize *
    sizeof(float)));
    */
 
    // Initialize matrices A and B with random values
    initialize_matrix_random(A, matrixSize);
    initialize_matrix_random(B, matrixSize);
 
    std::chrono::steady_clock::time_point mtx_start_time =
        std::chrono::steady_clock::now();
 
    // Print matrices A and B
    // print_matrix("Matrix A", A, matrixSize);
    // print_matrix("Matrix B", B, matrixSize);
 
    // Call the matrix addition function in assembly
    matrix_addition(A, B, C, matrixSize);
 
    std::chrono::steady_clock::time_point end_time =
        std::chrono::steady_clock::now();
 
    // Display the result matrix C
    // print_matrix("Result Matrix C", C, matrixSize);
 
    std::cout << "Generating random matrices (ARRAYS) - Time elapsed: "
              << std::chrono::duration_cast<std::chrono::milliseconds>(
                     mtx_start_time - gen_start_time)
                     .count()
              << " ms" << std::endl;
 
    std::cout << "Mtx add using ASM - Time elapsed: "
              << std::chrono::duration_cast<std::chrono::milliseconds>(
                     end_time - mtx_start_time)
                     .count()
              << " ms" << std::endl;
 
    // Free allocated memory
    delete[] A;
    delete[] B;
    delete[] C;
 
    return 0;
}

References python.linalg::A, python.linalg::B, python.linalg::C, initialize_matrix_random(), matrix_addition(), and matrixSize.

matrix_addition()

void matrix_addition	(	float *	A,
		float *	B,
		float *	C,
		int	matrixSize
	)

Referenced by main().

print_matrix()

void print_matrix	(	const char *	name,
		float *	matrix,
		int	matrixSize
	)

Definition at line 18 of file mtx_x86.c.

                                                                   {
    std::cout << name << ":\n";
    for (int i = 0; i < matrixSize; ++i) {
        for (int j = 0; j < matrixSize; ++j) {
            std::cout << matrix[i * matrixSize + j] << "\t";
        }
        std::cout << "\n";
    }
    std::cout << "\n";
}

References matrixSize.