Profiling_en_Python_e_instrucciones_AVX.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# **Paso 1: Crear las librerías de enlace dinámico (una sin AVX y otra con)**\n",
        "\n"
      ],
      "metadata": {
        "id": "3Sk_8yQtPIJv"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "*Librería de Enlace Dinámico sin AVX*"
      ],
      "metadata": {
        "id": "fECDIgdBhE2-"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "lrtDc0ifNS8A",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d3049274-61b2-465a-89f3-e50eb9f385e1"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Writing multescalar.c\n"
          ]
        }
      ],
      "source": [
        "%%writefile multescalar.c\n",
        "#include <immintrin.h>  // Esta librería proporciona funciones para operaciones intrínsecas de vectores en C.\n",
        "#include <stdio.h>  // Esta librería permite operaciones de entrada/salida estándar, como printf y scanf.\n",
        "#include <stdlib.h>\n",
        "#include <assert.h>  // Esta librería proporciona la macro assert, que se utiliza para realizar verificaciones en tiempo de ejecución.\n",
        "\n",
        "#define VECTORSIZE 4  // Define el tamaño del vector como 4.\n",
        "\n",
        "// Función para realizar la multiplicación de un vector por un escalar\n",
        "void vectorScalarMultiply(const double* vector, double scalar, double* result, int length) {\n",
        "    for (int i = 0; i < length; i++) {\n",
        "      result[i] = vector[i] * scalar;  // Multiplica cada elemento del vector por el escalar y almacena el resultado en el vector de resultado.\n",
        "    }\n",
        "}\n",
        "\n",
        "int main(int argc, char* argv[]) {\n",
        "    int vectorSize;\n",
        "    double *vector;\n",
        "    double scalar = 2.0;\n",
        "    double *result;\n",
        "\n",
        "    // Verifica si se proporciona un argumento de línea de comandos para el tamaño del vector, de lo contrario, utiliza el tamaño predeterminado definido por VECTORSIZE.\n",
        "    if (argc == 1) {\n",
        "        vectorSize = VECTORSIZE;\n",
        "    } else {\n",
        "        // Convierte el argumento de la línea de comandos a un entero (tamaño del vector).\n",
        "        vectorSize = atoi(argv[1]);\n",
        "    }\n",
        "\n",
        "    // Asigna memoria para el vector de acuerdo con el tamaño dado. La función malloc se utiliza para asignar memoria dinámica.\n",
        "    vector = (double*)malloc(sizeof(double)*vectorSize);\n",
        "    assert(vector != NULL);  // Verifica si la asignación de memoria ha sido exitosa.\n",
        "\n",
        "    result = (double*)malloc(sizeof(double)*vectorSize);\n",
        "    assert(result != NULL);  // Verifica si la asignación de memoria ha sido exitosa.\n",
        "\n",
        "    // Inicializa el vector con algunos valores.\n",
        "    for (int i = 0; i < vectorSize; ++i) {\n",
        "        vector[i] = i + 1;  // Llena el vector con valores, comenzando desde 1.\n",
        "    }\n",
        "\n",
        "    // Realiza la multiplicación de vector-escalar utilizando la función definida anteriormente.\n",
        "    vectorScalarMultiply(vector, scalar, result, vectorSize);\n",
        "\n",
        "    // Imprime el resultado.\n",
        "    #ifdef DEBUG\n",
        "    printf(\"Result:\\n\");\n",
        "    for (int i = 0; i < vectorSize; ++i) {\n",
        "        printf(\"%lf \", result[i]);  // Imprime los valores del vector resultante.\n",
        "    }\n",
        "#endif\n",
        "\n",
        "    // Libera la memoria asignada dinámicamente.\n",
        "    free(vector);\n",
        "    free(result);\n",
        "\n",
        "    return 0;  // Devuelve 0 para indicar una ejecución exitosa.\n",
        "}\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!gcc -shared -fpic -o libMultEscalar.so multescalar.c\n"
      ],
      "metadata": {
        "id": "hby_Yf0vPcTQ"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "*Libreria de Enlace dinámico con AVX*"
      ],
      "metadata": {
        "id": "BS4IGogsh4Br"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%writefile multescalar-avx.c\n",
        "/**\n",
        " * Este código fue desarrollado en colaboración con ChatGPT\n",
        " * Fecha: 05/03/2024\n",
        " * Autor: John Sanabria - john.sanabria@correounivalle.edu.co\n",
        " */\n",
        "\n",
        "#include <immintrin.h>  // Esta librer proporciona funciones para operaciones intrínsecas de vectores en C.\n",
        "#include <stdio.h>  // Esta librería permite operaciones de entrada/salida estándar, como printf y scanf.\n",
        "#include <assert.h>  // Esta librería proporciona la macro assert, se utiliza para realizar verificaciones en tiempo de ejecución.\n",
        "\n",
        "#define VECTORSIZE 4  // Define el tamaño del vector como 4.\n",
        "\n",
        "// Función para realizar la multiplicación de un vector por un escalar utilizando AVX instrucciones\n",
        "void vectorScalarMultiply(const double* vector, double scalar, double* result, int length) {\n",
        "    // Asegura que el length sea múltiplo de 4 para un alineamiento adecuado.\n",
        "    int alignedLength = (length + 3) & ~3;\n",
        "\n",
        "    // Itera a través del vector en bloques de 4 elementos.\n",
        "    for (int i = 0; i < alignedLength; i += 4) {\n",
        "        // Carga el bloque del vector en un registro AVX.\n",
        "        __m256d vec = _mm256_loadu_pd(vector + i);\n",
        "\n",
        "        // Transmite el valor escalar a todos los elementos de otro registro AVX.\n",
        "        __m256d scalarVec = _mm256_broadcast_sd(&scalar);\n",
        "\n",
        "        // Realiza la multiplicación elemento a elemento.\n",
        "        __m256d resultVec = _mm256_mul_pd(vec, scalarVec);\n",
        "\n",
        "        // Almacena el resultado en memoria.\n",
        "        _mm256_storeu_pd(result + i, resultVec);\n",
        "    }\n",
        "}\n",
        "\n",
        "int main(int argc, char* argv[]) {\n",
        "    // Datos de ejemplo.\n",
        "    int vectorSize;\n",
        "    double *vector;\n",
        "    double scalar = 2.0;\n",
        "    double *result;\n",
        "\n",
        "    if (argc == 1) {\n",
        "        vectorSize = VECTORSIZE;\n",
        "    } else {\n",
        "        vectorSize = atoi(argv[1]);\n",
        "    }\n",
        "    vector = (double*)malloc(sizeof(double)*vectorSize);\n",
        "    assert(vector != NULL);  // Verifica si la asignación de memoria ha sido exitosa.\n",
        "\n",
        "    result = (double*)malloc(sizeof(double)*vectorSize);\n",
        "    assert(result != NULL);  // Verifica si la asignación de memoria ha sido exitosa.\n",
        "\n",
        "    // Inicializa el vector con algunos valores.\n",
        "    for (int i = 0; i < vectorSize; ++i) {\n",
        "        vector[i] = i + 1;  // Llena el vector con valores, comenzando desde 1.\n",
        "    }\n",
        "\n",
        "    // Realiza la multiplicación vector-escalar utilizando la función definida anteriormente.\n",
        "    vectorScalarMultiply(vector, scalar, result, vectorSize);\n",
        "\n",
        "    // Imprime el resultado.\n",
        "    #ifdef DEBUG\n",
        "    printf(\"Vector Original:\\n\");\n",
        "    for (int i = 0; i < vectorSize; ++i) {\n",
        "        printf(\"%lf \", vector[i]);  // Imprime los valores del vector original.\n",
        "    }\n",
        "\n",
        "    printf(\"\\nEscalar: %lf\\n\", scalar);  // Imprime el valor del escalar.\n",
        "\n",
        "    printf(\"Resultado:\\n\");\n",
        "    for (int i = 0; i < vectorSize; ++i) {\n",
        "        printf(\"%lf \", result[i]);  // Imprime los valores del vector resultante.\n",
        "    }\n",
        "    #endif\n",
        "\n",
        "    // Libera la memoria asignada dinámicamente.\n",
        "    free(vector);\n",
        "    free(result);\n",
        "\n",
        "    return 0;  // Devuelve 0 para indicar una ejecución exitosa.\n",
        "}"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T9Vi__AciRWX",
        "outputId": "c8a482ac-a828-4f80-e2af-a4bd2c801fee"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Writing multescalar-avx.c\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "*comando de compilación para maquinas con arquitectura x86*"
      ],
      "metadata": {
        "id": "eT5ooTS7rQKj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!gcc -march=native -shared -fpic -o libMultEscalarAVX.so multescalar-avx.c"
      ],
      "metadata": {
        "id": "DY0TSg0difNn"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "*comando de compilación para máquinas con arquitectura x64*"
      ],
      "metadata": {
        "id": "rKBg_qqIrbnW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!gcc -march=native -mavx -shared -fPIC -o libMultEscalarAVX.so multescalar-avx.c"
      ],
      "metadata": {
        "id": "FT7K07aqrl6a"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "*Revisar que las librerias Dinámicas se hayan creado*"
      ],
      "metadata": {
        "id": "rubvDdJvjlel"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pwd && ls /content"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "klQmG9_3jt7o",
        "outputId": "57a4f048-8e88-46ac-a09e-bfd3ad343b8d"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/content\n",
            "libMultEscalarAVX.so  libMultEscalar.so  multescalar-avx.c  multescalar.c  sample_data\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Paso 2: Profiling en programa de Python (tiempos de ejecución con TimeIt y cProfile)**"
      ],
      "metadata": {
        "id": "Ykt16192Phqj"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "*Programa en Python en donde un Escalar multiplica a todos los valores de un vector*"
      ],
      "metadata": {
        "id": "bIKHKF3luFpQ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Se ejecuta el programa cinco veces, de esos tiempos se eliminan el tiempo más alto y bajo, con el objetivo de minimizar la variabilidad y dispersión de los tiempos, el tiempo promedio se sacará de los tiempos restantes"
      ],
      "metadata": {
        "id": "33JBJLRcBfic"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "*Profiling con el módulo timeit*"
      ],
      "metadata": {
        "id": "flFVLZrbulPC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import timeit\n",
        "\n",
        "def profiling_Timeit():\n",
        "  starting_time = timeit.default_timer()\n",
        "  n = 10000000\n",
        "  lst = list(range(0, n))\n",
        "  x = 2\n",
        "  v = lst.copy()\n",
        "\n",
        "  for i in range(len(lst)):\n",
        "      v[i] = lst[i] * x\n",
        "  ending_time = timeit.default_timer()\n",
        "\n",
        "  print(f\"Tiempo transcurrido {ending_time - starting_time}\")\n",
        "\n",
        "# Ejecutar el programa múltiples veces y tomar los tiempos\n",
        "num_repeticiones = 5\n",
        "tiempos = timeit.repeat(\"profiling_Timeit()\", setup=\"from __main__ import profiling_Timeit\", number=1, repeat=num_repeticiones)\n",
        "\n",
        "# Calcular el tiempo promedio\n",
        "min_tiempo = min(tiempos)\n",
        "max_tiempo = max(tiempos)\n",
        "tiempos_restantes = tiempos[1:4]  # Los 3 tiempos restantes\n",
        "tiempo_promedio_restante = sum(tiempos_restantes) / len(tiempos_restantes)\n",
        "\n",
        "print(\"Tiempo promedio de ejecución:\", tiempo_promedio_restante)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kXmwIsB5uiyE",
        "outputId": "d76a307d-d51e-43b2-ab3f-e41371ed30c1"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Tiempo transcurrido 0.8417070969999827\n",
            "Tiempo transcurrido 0.8172937540000191\n",
            "Tiempo transcurrido 1.1780892029999848\n",
            "Tiempo transcurrido 0.8176225739999836\n",
            "Tiempo transcurrido 0.8477252380000095\n",
            "Tiempo promedio de ejecución: 1.094217320333333\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "*Profiling con el módulo cProfile*"
      ],
      "metadata": {
        "id": "MeWsyiNH0iMD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import cProfile as profile\n",
        "import pstats\n",
        "\n",
        "def profiling_cProfile():\n",
        "\n",
        "  n = 10000000\n",
        "  lst = list(range(0, n))\n",
        "  x = 2\n",
        "  v = lst.copy()\n",
        "\n",
        "  for i in range(len(lst)):\n",
        "      v[i] = lst[i] * x\n",
        "\n",
        "# Ejecutamos el programa y realizamos el profiling\n",
        "prof = profile.Profile()\n",
        "\n",
        "# Inicializamos la lista de tiempos\n",
        "tiempos = []\n",
        "\n",
        "# Ejecutamos el programa 5 veces y tomamos los tiempos\n",
        "num_repeticiones = 5\n",
        "for _ in range(num_repeticiones): #el uso de _ es como una convención para indicar que el valor del bucle no se va a usar en el cuerpo del bucle\n",
        "    prof.enable()\n",
        "    profiling_cProfile()\n",
        "    prof.disable()\n",
        "    stats = pstats.Stats(prof).strip_dirs().sort_stats(\"cumtime\")\n",
        "\n",
        "    # Obtenemos el tiempo de ejecución de la última llamada\n",
        "    tiempo_ejecucion = stats.total_tt\n",
        "    tiempos.append(tiempo_ejecucion)\n",
        "\n",
        "# Obtenemos el tiempo máximo y mínimo\n",
        "tiempo_maximo = max(tiempos)\n",
        "tiempo_minimo = min(tiempos)\n",
        "\n",
        "# Eliminamos los tiempos max y min de la lista\n",
        "tiempos_sin_max_min = [t for t in tiempos if t != tiempo_maximo and t != tiempo_minimo]\n",
        "\n",
        "# Calculamos el tiempo promedio con los tiempos restantes\n",
        "tiempo_promedio = sum(tiempos_sin_max_min) / len(tiempos_sin_max_min)\n",
        "print(\"Tiempo promedio de ejecución:\", tiempo_promedio)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3tygtX_20hpc",
        "outputId": "e1f56541-5912-44cf-a1aa-a3f7ef6c9485"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Tiempo promedio de ejecución: 3.4785058400000004\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "*Ahora que se tienen los tiempos promedio del programa con los módulos timeIt y cProfile, se saca su tiempo promedio para obtener el* **tiempo Ingenuo**"
      ],
      "metadata": {
        "id": "95rOzPOFClry"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "Tiempo_timeIt = 1.094217320333333\n",
        "Timepo_cProfile = 3.4785058400000004\n",
        "\n",
        "Tiempo_Ingenuo = (Tiempo_timeIt + Timepo_cProfile) / 2\n",
        "\n",
        "print(f\"El tiempo Ingenuo es: {Tiempo_Ingenuo}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fsRzsQClDmlF",
        "outputId": "1086a123-53ea-4c23-e69f-2638f6a2575e"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "El tiempo Ingenuo es: 2.2863615801666666\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Paso 3: Ejecución del programa Python con la librería Dinámica con AVX, medición de tiempo con el módulo cProfile**"
      ],
      "metadata": {
        "id": "8iOxaXkCPxyK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "import ctypes  # Librería para invocar funciones de bibliotecas dinámicas escritas en C\n",
        "import cProfile  # Librería para medir el desempeño y tiempo de ejecución del código\n",
        "import array  # Librería para manejar arreglos de datos eficientemente\n",
        "import pstats  # Librería para generar y procesar estadísticas de tiempo de ejecución\n",
        "\n",
        "# Cargar la librería dinámica que contiene la función de multiplicación vector-escalar escrita en C\n",
        "lib = ctypes.CDLL(\"/content/libMultEscalarAVX.so\")\n",
        "\n",
        "# Declarar los tipos de los argumentos y el tipo de retorno de la función vectorScalarMultiply en la librería dinámica\n",
        "lib.vectorScalarMultiply.argtypes = [ctypes.c_void_p, ctypes.c_double, ctypes.c_void_p, ctypes.c_int]\n",
        "lib.vectorScalarMultiply.restype = None\n",
        "\n",
        "# Crear un vector con 10 millones de datos utilizando la librería array para una manipulación eficiente\n",
        "vector_size = 10000000\n",
        "vector = array.array('d', range(1, vector_size + 1))\n",
        "\n",
        "# Inicializar el escalar que se utilizará para la multiplicación\n",
        "scalar = 2.0\n",
        "\n",
        "# Crear un array para almacenar el resultado de la multiplicación\n",
        "result = (ctypes.c_double * len(vector))()\n",
        "\n",
        "# Ejecutar el código dentro del contexto del perfilador cProfile para medir el tiempo de ejecución\n",
        "pr = cProfile.Profile()  # Inicialización del perfilador\n",
        "pr.enable()  # Iniciar la medición de tiempo\n",
        "lib.vectorScalarMultiply((ctypes.c_double * len(vector))(*vector), scalar, result, vector_size)  # Llamada a la función en la librería dinámica\n",
        "pr.disable()  # Finalizar la medición de tiempo\n",
        "\n",
        "# Obtener estadísticas de tiempo de ejecución y limitar la impresión a las 10 líneas más relevantes\n",
        "stats = pstats.Stats(pr).strip_dirs().sort_stats(\"cumtime\")\n",
        "stats.print_stats(10)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xYOI9rdXVV_s",
        "outputId": "8f093ad1-72f0-4392-9367-b5d37bb3828c"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "         60 function calls in 1.028 seconds\n",
            "\n",
            "   Ordered by: cumulative time\n",
            "   List reduced from 27 to 10 due to restriction <10>\n",
            "\n",
            "   ncalls  tottime  percall  cumtime  percall filename:lineno(function)\n",
            "        2    0.000    0.000    1.028    0.514 interactiveshell.py:3512(run_code)\n",
            "        2    0.000    0.000    1.028    0.514 {built-in method builtins.exec}\n",
            "        1    1.028    1.028    1.028    1.028 <ipython-input-14-04f72c439bb7>:1(<cell line: 26>)\n",
            "        2    0.000    0.000    0.000    0.000 codeop.py:117(__call__)\n",
            "        2    0.000    0.000    0.000    0.000 {built-in method builtins.compile}\n",
            "        2    0.000    0.000    0.000    0.000 interactiveshell.py:3337(_update_code_co_name)\n",
            "        6    0.000    0.000    0.000    0.000 {built-in method builtins.next}\n",
            "        2    0.000    0.000    0.000    0.000 contextlib.py:279(helper)\n",
            "        2    0.000    0.000    0.000    0.000 traitlets.py:689(__get__)\n",
            "        4    0.000    0.000    0.000    0.000 dis.py:453(findlinestarts)\n",
            "\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<pstats.Stats at 0x7c6f27fb7fa0>"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "Tiempo_Ingenio = 2.2863615801666666\n",
        "Tiempo_AVX = 1.028\n",
        "\n",
        "print(f\"Speed Up AVX = {Tiempo_Ingenuo / Tiempo_AVX}\")\n"
      ],
      "metadata": {
        "id": "qxB_MAf2P1XC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "65ae3984-48ff-4bd1-ef21-8f5cda3b1079"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Speed Up AVX = 2.224087140239948\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "*El programa python con el uso de la librería AVX es 2.2 veces mejor que el programa analógico de python*"
      ],
      "metadata": {
        "id": "Au_JeQIPdsYf"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Paso 4: Ejecución del programa Python con la librería Dinámica sin AVX usando Numpy, medición de tiempo con el módulo cProfile**"
      ],
      "metadata": {
        "id": "yoEvdHTZP_4T"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "import ctypes  # Librería para acceder a bibliotecas/herramientas de bajo nivel escritas en C\n",
        "import numpy as np  # Librería de Python para operaciones matemáticas avanzadas y estructuras de datos eficientes\n",
        "import cProfile  # Librería para realizar perfiles de código y medir el tiempo de ejecución de las funciones\n",
        "import pstats  # Librería para procesar y mostrar estadísticas de los perfiles realizados\n",
        "\n",
        "# Cargar la librería dinámica que contiene la función de multiplicación vector-escalar escrita en C\n",
        "lib = ctypes.CDLL(\"/content/libMultEscalar.so\")\n",
        "\n",
        "# Especificar los tipos de argumentos y el tipo de retorno de la función vectorScalarMultiply en la librería dinámica\n",
        "lib.vectorScalarMultiply.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.c_double,\n",
        "                                     ctypes.POINTER(ctypes.c_double), ctypes.c_int]\n",
        "lib.vectorScalarMultiply.restype = None\n",
        "\n",
        "def vector_scalar_multiply(vector, scalar):\n",
        "    length = len(vector)\n",
        "    result = np.empty(length, dtype=np.float64)  # Crear un array en numpy para almacenar el resultado de la multiplicación\n",
        "\n",
        "    # Ejecutar el código dentro del contexto del perfilador cProfile para medir el tiempo de ejecución\n",
        "\n",
        "    lib.vectorScalarMultiply((ctypes.c_double * len(vector))(*vector), scalar,\n",
        "                             result.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), length)  # Llamar a la función de la librería dinámica\n",
        "\n",
        "    return result\n",
        "\n",
        "# Generar un vector de tamaño 10 millones utilizando la librería numpy\n",
        "vector = np.arange(1, 10000001, dtype=np.float64)  # Crear un vector de números de 1 a 10000000\n",
        "scalar = 2.0  # Valor escalar para la multiplicación\n",
        "\n",
        "pr = cProfile.Profile()  # Inicializar un perfilador\n",
        "# Ejecutar la función de multiplicación vector-escalar con el contexto de cProfile para medir el tiempo\n",
        "pr.enable()  # Iniciar la medición de tiempo\n",
        "vector_scalar_multiply(vector, scalar)  # Llamar a la función de multiplicación\n",
        "pr.disable()  # Terminar la medición de tiempo\n",
        "\n",
        "# Obtener las estadísticas y limitar la impresión a las 10 líneas con mayor tiempo acumulado\n",
        "stats = pstats.Stats(pr).strip_dirs().sort_stats(\"cumtime\")  # Crear estadísticas basadas en el perfil\n",
        "stats.print_stats(10)  # Imprimir las 10 líneas con mayor tiempo acumulado\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WgXyNtaqgSJ2",
        "outputId": "ad018068-0008-4003-e3fd-b6d52a204969"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "         67 function calls in 2.733 seconds\n",
            "\n",
            "   Ordered by: cumulative time\n",
            "   List reduced from 33 to 10 due to restriction <10>\n",
            "\n",
            "   ncalls  tottime  percall  cumtime  percall filename:lineno(function)\n",
            "        2    0.000    0.000    2.733    1.367 interactiveshell.py:3512(run_code)\n",
            "        2    0.000    0.000    2.733    1.367 {built-in method builtins.exec}\n",
            "        1    0.000    0.000    2.733    2.733 <ipython-input-18-f814618a82a3>:1(<cell line: 32>)\n",
            "        1    2.732    2.732    2.733    2.733 <ipython-input-18-f814618a82a3>:14(vector_scalar_multiply)\n",
            "        1    0.000    0.000    0.000    0.000 _internal.py:267(data_as)\n",
            "        1    0.000    0.000    0.000    0.000 __init__.py:509(cast)\n",
            "        1    0.000    0.000    0.000    0.000 _internal.py:250(__init__)\n",
            "        2    0.000    0.000    0.000    0.000 codeop.py:117(__call__)\n",
            "        2    0.000    0.000    0.000    0.000 {built-in method builtins.compile}\n",
            "        1    0.000    0.000    0.000    0.000 {built-in method numpy.empty}\n",
            "\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<pstats.Stats at 0x7c6f27fb7df0>"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "Tiempo_Ingenio = 2.2863615801666666\n",
        "Tiempo_Numpy = 2.733\n",
        "\n",
        "print(f\"Speed Up Numpy = {Tiempo_Ingenuo / Tiempo_Numpy}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MhZPO4iRlUEb",
        "outputId": "cc70b7fa-9d2e-4419-dead-98d9e0737dcd"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Speed Up Numpy = 0.8365757702768629\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "*El speed Up del programa en Python usando Numpy, no supera la cantidad de 1, por consiguiente, este programa no logra una mejora significativa frente al programa de python analógico*"
      ],
      "metadata": {
        "id": "WbSv5sZslbfW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "**Conclusiones**"
      ],
      "metadata": {
        "id": "JiKbHYTKibxd"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Con esta tarea se concluye que el programa de python que usa la libreria dinámica con AVX es almenos 2.2 veces mejor que el programa de python analógico, el programa de python que usa la libreria Numpy y la libreria dinámica de C no alcanza a tener una mejora de tiempo frente al programa analógico.  "
      ],
      "metadata": {
        "id": "Ca9gJBEPihwS"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "\n",
        "**Integrantes:** <br>\n",
        "  » Néstor David Heredia Gutierrez - 2058558 <br>\n",
        "  » Brayan Camilo Urrea Jurado - 2410023 <br>\n",
        "  » Kevin Alejandro Velez Agudelo - 2123281"
      ],
      "metadata": {
        "id": "kKFruprCjnMT"
      }
    }
  ]
}