HPC12_GuiaCompilacionEjecucionOpenMP.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1 align=\"center\">Computación de Alto Desempeño</h1>\n",
    "<h1 align=\"center\">OpenMP - Guía de Compilación y Ejecución</h1>\n",
    "<h1 align=\"center\">2024</h1>\n",
    "<h1 align=\"center\">MEDELLÍN - COLOMBIA </h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "|[![Outlook](https://img.shields.io/badge/Microsoft_Outlook-0078D4?style=plastic&logo=microsoft-outlook&logoColor=white)](mailto:calvarezh@udemedellin.edu.co)||[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/carlosalvarezh/HPC/blob/main/HPC12_GuiaCompilacionEjecucionOpenMP.ipynb)\n",
    "|-:|:-|--:|\n",
    "|[![LinkedIn](https://img.shields.io/badge/linkedin-%230077B5.svg?style=plastic&logo=linkedin&logoColor=white)](https://www.linkedin.com/in/carlosalvarez5/)|[![@alvarezhenao](https://img.shields.io/twitter/url/https/twitter.com/alvarezhenao.svg?style=social&label=Follow%20%40alvarezhenao)](https://twitter.com/alvarezhenao)|[![@carlosalvarezh](https://img.shields.io/badge/github-%23121011.svg?style=plastic&logo=github&logoColor=white)](https://github.com/carlosalvarezh)|\n",
    "\n",
    "<table>\n",
    " <tr align=left><td><img align=left src=\"https://github.com/carlosalvarezh/Curso_CEC_EAFIT/blob/main/images/CCLogoColorPop1.gif?raw=true\" width=\"25\">\n",
    " <td>Text provided under a Creative Commons Attribution license, CC-BY. All code is made available under the FSF-approved MIT license.(c) Carlos Alberto Alvarez Henao</td>\n",
    "</table>\n",
    "\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Guía para Compilar y Ejecutar Programas en C con OpenMP en Ambientes Linux y Windows Usando Visual Studio Code**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esta guía te ayudará a compilar y ejecutar programas en **C** con **OpenMP** tanto en **Linux** como en **Windows**, utilizando **Visual Studio Code**. Se explicará cómo hacerlo manualmente desde la consola y cómo usar archivos de tareas en diferentes programas y plataformas para automatizar la compilación."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **1. Compilación y Ejecución en Ambientes Linux**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **A. Compilación y Ejecución Manual desde la Consola en Linux**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Paso 1: Instalar GCC con soporte para OpenMP**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En la mayoría de las distribuciones de Linux, el compilador GCC ya incluye soporte para OpenMP. Si no lo tienes instalado, puedes instalarlo con los siguientes comandos:\n",
    "\n",
    "- **En Ubuntu/Debian**:\n",
    "\n",
    "    ```bash\n",
    "    sudo apt update\n",
    "    sudo apt install gcc\n",
    "    ```\n",
    "\n",
    "- **En Fedora/CentOS**:\n",
    "\n",
    "    ```bash\n",
    "    sudo dnf install gcc\n",
    "    ```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Paso 2: Escribir el código en C con OpenMP**\n",
    "\n",
    "Crea un archivo con extensión **`.c`** y escribe tu código C con OpenMP (en esta guía lo llamaremos `ejemplo.c`)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Paso 3: Compilar el código en Linux**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para compilar este código en Linux utilizando **GCC** con soporte de **OpenMP**, usa el siguiente comando en la terminal:\n",
    "\n",
    "```bash\n",
    "gcc -fopenmp -o ejemplo ejemplo.c\n",
    "```\n",
    "\n",
    "- **`-fopenmp`**: Habilita el soporte de OpenMP.\n",
    "- **`-o ejemplo`**: Especifica que el archivo ejecutable se llamará `ejemplo`.\n",
    "- **`ejemplo.c`**: Es el nombre del archivo fuente en C.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Paso 4: Ejecutar el código en Linux**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ejecuta el programa resultante usando el siguiente comando en la terminal:\n",
    "\n",
    "```bash\n",
    "./ejemplo\n",
    "```\n",
    "\n",
    "El programa imprimirá el tiempo de ejecución, algo como:\n",
    "\n",
    "```bash\n",
    "Tiempo de ejecución: 0.345623 segundos\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Paso 5: Configurar variables de entorno para mejorar el rendimiento**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las variables de entorno en OpenMP permiten ajustar y controlar el comportamiento de los programas paralelos de forma eficiente, mejorando el uso de los recursos del sistema y el rendimiento general del programa. Este procedimiento se realiza desde la consola (o terminal)\n",
    "\n",
    "- **Ejemplo:**\n",
    "\n",
    "```bash\n",
    "export OMP_PROC_BIND=true\n",
    "export OMP_PLACES=cores\n",
    "./ejemplo\n",
    "```\n",
    "\n",
    "- **`OMP_PROC_BIND=true`**: Asegura que los *threads* no migren entre núcleos.\n",
    "- **`OMP_PLACES=cores`**: Asigna los *threads* a núcleos físicos.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **2. Compilación y Ejecución en Ambientes Windows**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **A. Compilación y Ejecución Manual desde la Consola en Windows**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Paso 1: Instalar MinGW en Windows**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "MinGW es una colección de herramientas que incluye **GCC** para Windows. Sigue estos pasos para instalarlo:\n",
    "\n",
    "1. Descarga MinGW desde: https://sourceforge.net/projects/mingw/.\n",
    "2. Instala el paquete y asegúrate de seleccionar **gcc**, **g++** y **gfortran**.\n",
    "3. Agrega el directorio `C:\\MinGW\\bin` a la variable de entorno **Path**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Paso 2: Verificar la instalación de GCC**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Abre una terminal (o **PowerShell**) y escribe:\n",
    "\n",
    "```bash\n",
    "gcc --version\n",
    "```\n",
    "\n",
    "Si ves la versión de GCC, todo está listo.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Paso 3: Compilar el código en Windows**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Abre la terminal o la terminal integrada en **VS Code** y navega a la carpeta donde guardaste tu archivo `.c`. Usa el siguiente comando para compilar:\n",
    "\n",
    "```bash\n",
    "gcc -fopenmp -o ejemplo.exe ejemplo.c\n",
    "```\n",
    "\n",
    "Este comando genera un archivo ejecutable llamado `ejemplo.exe`.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Paso 4: Ejecutar el programa en Windows**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ejecuta el archivo compilado:\n",
    "\n",
    "```bash\n",
    "./ejemplo.exe\n",
    "```\n",
    "\n",
    "El programa imprimirá el tiempo de ejecución:\n",
    "\n",
    "```bash\n",
    "Tiempo de ejecución: 0.345623 segundos\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Paso 5: Configurar variables de entorno en Windows**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Desde **PowerShell** o la terminal integrada en **VS Code**, puedes configurar variables de entorno para mejorar el rendimiento del programa.\n",
    "\n",
    "- **Ejemplo**:\n",
    "\n",
    "```bash\n",
    "$env:OMP_PROC_BIND=\"true\"\n",
    "$env:OMP_PLACES=\"cores\"\n",
    "./ejemplo.exe\n",
    "```\n",
    "\n",
    "Estas configuraciones ajustan la afinidad de los *threads* para mejorar el rendimiento.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **3. Automatización de la Compilación: Uso de Archivos de Compilación en Diferentes Plataformas y Entornos**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La automatización de tareas de compilación y ejecución es fundamental en el desarrollo de software, especialmente cuando se trabaja en proyectos más complejos. Para facilitar este proceso, muchos entornos de desarrollo y editores de código proporcionan formas de definir tareas automatizadas, como la compilación, pruebas, y ejecución de programas. A continuación, ampliaremos el concepto de los archivos de compilación y automatización para diferentes plataformas y entornos de desarrollo, como **Visual Studio Code**, **Sublime Text**, **Makefiles**, **CMake**, **JetBrains CLion**, y **Visual Studio**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **3.1 `tasks.json` en Visual Studio Code**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En **Visual Studio Code (VS Code)**, puedes automatizar tareas de compilación y otras operaciones mediante un archivo de configuración llamado **`tasks.json`**. Este archivo permite ejecutar comandos de compilación, ejecución de programas, y pruebas directamente dentro del entorno de desarrollo sin necesidad de abrir manualmente la terminal.\n",
    "\n",
    "**Estructura de `tasks.json`**:\n",
    "- **Versión**: Especifica la versión del esquema de tareas.\n",
    "- **Tareas**: Define las tareas que se pueden ejecutar, como la compilación o ejecución de programas.\n",
    "- **Comando**: El comando que se ejecutará (por ejemplo, `gcc` para compilar código en C).\n",
    "- **Argumentos (`args`)**: Los argumentos que se pasarán al comando, como las banderas de compilación.\n",
    "\n",
    "**¿Qué es `tasks.json`?**\n",
    "- **`tasks.json`** es un archivo de configuración en formato JSON que define una serie de tareas automáticas que VS Code puede ejecutar.\n",
    "- Cada tarea tiene una etiqueta (**label**) y especifica qué comando se debe ejecutar, los argumentos, el entorno, y otros detalles.\n",
    "- Se encuentra dentro de la carpeta `.vscode` del proyecto y se utiliza para optimizar flujos de trabajo repetitivos.\n",
    "\n",
    "**¿Por qué usar un archivo de tareas?**\n",
    "- **Automatización**: En lugar de recordar y escribir manualmente los comandos de compilación cada vez, puedes ejecutarlos con un simple atajo de teclado.\n",
    "- **Estandarización**: En equipos de trabajo, puedes compartir un archivo `tasks.json` para que todos los desarrolladores utilicen los mismos comandos y configuraciones.\n",
    "- **Integración**: Las tareas se pueden integrar con la terminal integrada de VS Code, lo que hace que todo el flujo de trabajo sea más sencillo y rápido.\n",
    "\n",
    "**Uso de `tasks.json` (Compilación de Programas con OpenMP)**\n",
    "\n",
    "En este caso, **`tasks.json`** se utiliza para **automatizar la compilación del programa C con soporte OpenMP**. Normalmente, tendrías que escribir manualmente el comando de compilación en la terminal cada vez que modificas el código. Con un archivo de tareas, puedes configurar VS Code para que compile automáticamente el archivo C con OpenMP con un solo atajo de teclado.\n",
    "\n",
    "**Ejemplo de `tasks.json` para Compilar C con OpenMP**\n",
    "\n",
    "Aquí tienes un ejemplo de un archivo `tasks.json` que define una tarea para compilar un archivo C con soporte OpenMP en Linux:\n",
    "\n",
    "```json\n",
    "{\n",
    "    \"version\": \"2.0.0\",\n",
    "    \"tasks\": [\n",
    "        {\n",
    "            \"label\": \"Compilar C OpenMP\",  // Nombre de la tarea\n",
    "            \"type\": \"shell\",               // Tipo de tarea, que usa la terminal (shell)\n",
    "            \"command\": \"gcc\",              // Comando principal: el compilador GCC\n",
    "            \"args\": [\n",
    "                \"-fopenmp\",                // Habilitar soporte OpenMP\n",
    "                \"-o\",                      // Especificar el nombre del archivo ejecutable\n",
    "                \"${fileDirname}/${fileBasenameNoExtension}\",  // Nombre del ejecutable según el archivo fuente\n",
    "                \"${file}\"                  // Archivo fuente en C a compilar\n",
    "            ],\n",
    "            \"group\": {\n",
    "                \"kind\": \"build\",           // Tipo de tarea: \"build\" para construir (compilar)\n",
    "                \"isDefault\": true          // Especifica que esta es la tarea predeterminada\n",
    "            },\n",
    "            \"problemMatcher\": [\"$gcc\"],    // Ayuda a VS Code a detectar errores del compilador GCC\n",
    "            \"detail\": \"Compilación de código C con soporte OpenMP\" // Descripción de la tarea\n",
    "        }\n",
    "    ]\n",
    "}\n",
    "```\n",
    "\n",
    "**Explicación del Ejemplo**:\n",
    "\n",
    "1. **`version`:** Define la versión del esquema JSON de tareas (aquí, la versión 2.0).\n",
    "2. **`label`:** El nombre que se le da a la tarea. En este caso, \"Compilar C OpenMP\".\n",
    "3. **`command`:** El comando que se ejecutará, aquí es `gcc`, que es el compilador de C.\n",
    "4. **`args`:** Los argumentos que se pasan al compilador:\n",
    "   - `-fopenmp`: Habilita el soporte de OpenMP.\n",
    "   - `-o`: Define el nombre del archivo ejecutable que se creará.\n",
    "   - `${fileDirname}/${fileBasenameNoExtension}`: Usa el nombre del archivo fuente sin la extensión `.c` como nombre del ejecutable.\n",
    "   - `${file}`: Se refiere al archivo fuente C que está abierto en ese momento en VS Code.\n",
    "5. **`group`:** Define que esta es una tarea de compilación (build) y que es la tarea predeterminada (`isDefault`).\n",
    "6. **`problemMatcher`:** Ayuda a VS Code a identificar errores de compilación generados por GCC.\n",
    "\n",
    "**Ejecutar la Tarea en VS Code**:\n",
    "\n",
    "- Después de configurar `tasks.json`, puedes compilar tu programa presionando `Ctrl + Shift + B` o yendo al menú **Terminal -> Run Build Task**. Esto ejecutará la tarea definida en `tasks.json`, que compilará el archivo C con soporte OpenMP.\n",
    "\n",
    "**Beneficios de Usar `tasks.json` en VS Code**:\n",
    "- **Rapidez**: No necesitas escribir el comando de compilación cada vez que haces cambios en el código.\n",
    "- **Organización**: Todas las configuraciones de compilación se guardan en un solo archivo, lo que hace que el proceso sea más organizado y reutilizable.\n",
    "- **Flexibilidad**: Puedes crear diferentes tareas para distintas configuraciones o modos de compilación (por ejemplo, para compilar con depuración o sin ella).\n",
    "\n",
    "En resumen, usar **`tasks.json`** en VS Code te permite **automatizar la compilación** de programas en C con OpenMP, lo que ahorra tiempo y hace el flujo de trabajo más eficiente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **3.2. `*.sublime-build` en Sublime Text**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En **Sublime Text**, los archivos de compilación (`*.sublime-build`) permiten automatizar la compilación de código dentro del editor, similar a lo que hace `tasks.json` en VS Code. Estos archivos son archivos JSON que configuran el compilador y los comandos que se ejecutarán al compilar.\n",
    "\n",
    "**Estructura de un Archivo `sublime-build`**:\n",
    "- **cmd**: El comando que se ejecutará para compilar el archivo.\n",
    "- **file_regex**: Opcional, ayuda a identificar y resaltar errores de compilación.\n",
    "- **selector**: Define qué tipo de archivo utilizará esta configuración (por ejemplo, `source.c` para archivos C).\n",
    "\n",
    "**Ejemplo para Compilar C con OpenMP en Sublime Text**:\n",
    "\n",
    "```json\n",
    "{\n",
    "    \"cmd\": [\"gcc\", \"-fopenmp\", \"-o\", \"$file_base_name\", \"$file\"],\n",
    "    \"file_regex\": \"^(...*?):([0-9]*):?([0-9]*)\",\n",
    "    \"working_dir\": \"$file_path\",\n",
    "    \"selector\": \"source.c\"\n",
    "}\n",
    "```\n",
    "\n",
    "**Beneficios**:\n",
    "- **Personalización**: Puedes definir configuraciones específicas para diferentes lenguajes y compiladores.\n",
    "- **Rápida Ejecución**: Al presionar `Ctrl + B`, Sublime Text compilará automáticamente el archivo abierto.\n",
    "- **Flexibilidad**: Puedes definir diferentes entornos de compilación para múltiples lenguajes.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **3.3. **Makefiles**: Automatización Tradicional en Entornos de Desarrollo**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Makefiles** son archivos de configuración utilizados por la herramienta **Make** para automatizar la compilación de programas. **Make** es muy común en entornos de desarrollo basados en Unix/Linux y es extremadamente flexible. Un **Makefile** define reglas de compilación, listas de dependencias, y comandos que se ejecutan cuando se necesita compilar o construir un proyecto.\n",
    "\n",
    "**Estructura de un Makefile**:\n",
    "- **Reglas**: Definen qué debe hacerse y qué archivos están involucrados.\n",
    "- **Dependencias**: Especifican qué archivos o módulos deben compilarse antes de otros.\n",
    "- **Comandos**: Son los comandos que se ejecutan para llevar a cabo las tareas.\n",
    "\n",
    "**Ejemplo de Makefile para un Proyecto C con OpenMP**:\n",
    "\n",
    "```bash\n",
    "CC = gcc\n",
    "CFLAGS = -fopenmp\n",
    "TARGET = programa\n",
    "\n",
    "all: $(TARGET)\n",
    "\n",
    "$(TARGET): programa.o\n",
    "    $(CC) $(CFLAGS) -o $(TARGET) programa.o\n",
    "\n",
    "programa.o: programa.c\n",
    "    $(CC) $(CFLAGS) -c programa.c\n",
    "\n",
    "clean:\n",
    "    rm -f *.o $(TARGET)\n",
    "```\n",
    "\n",
    "**Beneficios**:\n",
    "- **Extremadamente Flexible**: Puedes definir reglas y dependencias para cualquier tipo de proyecto, desde simples programas C hasta complejas aplicaciones con múltiples módulos.\n",
    "- **Independencia del Editor**: Puedes usar **Makefiles** en cualquier editor o entorno, ya que funcionan directamente desde la terminal.\n",
    "- **Eficiencia**: Sólo recompila los archivos que han cambiado, lo que ahorra tiempo en grandes proyectos.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **3.4. CMake: Gestión Avanzada de Proyectos**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**CMake** es una herramienta de código abierto que genera **Makefiles** u otros scripts de construcción para compilar proyectos en múltiples plataformas. Es particularmente útil para proyectos grandes y multiplataforma, ya que simplifica la administración de dependencias, la configuración del proyecto y la creación de reglas de compilación.\n",
    "\n",
    "**Estructura de un CMakeLists.txt**:\n",
    "- **Project**: Define el nombre y la versión del proyecto.\n",
    "- **add_executable**: Especifica el nombre del ejecutable y los archivos fuente.\n",
    "- **target_link_libraries**: Añade bibliotecas (como OpenMP) a los proyectos.\n",
    "\n",
    "**Ejemplo de Archivo `CMakeLists.txt` para OpenMP**:\n",
    "\n",
    "```bash\n",
    "cmake_minimum_required(VERSION 3.10)\n",
    "\n",
    "# Nombre del proyecto\n",
    "project(MiPrograma C)\n",
    "\n",
    "# Habilitar soporte para OpenMP\n",
    "find_package(OpenMP REQUIRED)\n",
    "add_executable(programa programa.c)\n",
    "target_link_libraries(programa PUBLIC OpenMP::OpenMP_C)\n",
    "```\n",
    "\n",
    "**Beneficios**:\n",
    "- **Multiplataforma**: CMake genera archivos de compilación para múltiples plataformas (Linux, Windows, macOS).\n",
    "- **Modular**: Facilita la gestión de proyectos grandes con múltiples dependencias.\n",
    "- **Integración**: Se integra bien con otros entornos de desarrollo como **CLion** y **Visual Studio**.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **3.5. JetBrains CLion: Automatización con CMake**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**CLion**, un entorno de desarrollo integrado de **JetBrains**, utiliza **CMake** como su sistema de construcción principal. Cada proyecto de **CLion** requiere un archivo `CMakeLists.txt` para compilar el código, gestionar dependencias, y definir configuraciones de compilación.\n",
    "\n",
    "**Beneficios**:\n",
    "- **CMake Integrado**: La configuración del proyecto en **CLion** está completamente basada en **CMake**, por lo que no necesitas configuraciones adicionales.\n",
    "- **Facilidad de uso**: CLion proporciona una interfaz gráfica para gestionar configuraciones de CMake.\n",
    "- **Autocompletado**: CLion es conocido por su excelente autocompletado y refactorización de código.\n",
    "\n",
    "**Ejemplo**:\n",
    "Al abrir un proyecto en **CLion**, se generará automáticamente un archivo `CMakeLists.txt`, donde puedes definir tus configuraciones de compilación:\n",
    "\n",
    "```bash\n",
    "cmake_minimum_required(VERSION 3.10)\n",
    "project(MiProyecto)\n",
    "set(CMAKE_CXX_STANDARD 11)\n",
    "\n",
    "find_package(OpenMP REQUIRED)\n",
    "add_executable(MiProyecto main.cpp)\n",
    "target_link_libraries(MiProyecto OpenMP::OpenMP_CXX)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **3.6. Visual Studio: Proyectos y Soluciones**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En **Visual Studio** (para Windows y macOS), la compilación y ejecución de programas está gestionada a través de **proyectos y soluciones**. Un proyecto contiene todos los archivos de código fuente, dependencias, y configuraciones necesarias para construir una aplicación. Visual Studio facilita la automatización de la compilación y ejecución mediante su entorno gráfico.\n",
    "\n",
    "**Configuración de OpenMP en Visual Studio**:\n",
    "Para habilitar OpenMP en un proyecto de **Visual Studio**:\n",
    "\n",
    "1. Abre tu proyecto en Visual Studio.\n",
    "2. Ve a **Project -> Properties**.\n",
    "3. En la sección **C/C++ -> Language**, habilita **OpenMP Support**.\n",
    "4. Compila y ejecuta el\n",
    "\n",
    " proyecto desde el entorno.\n",
    "\n",
    "**Beneficios**:\n",
    "- **Entorno completo**: Visual Studio ofrece herramientas integradas para el depurado, pruebas, análisis de rendimiento, y más.\n",
    "- **Gran soporte para Windows**: Ideal para el desarrollo de software nativo en Windows.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Resumen**\n",
    "\n",
    "Automatizar la compilación y ejecución de programas es una parte crucial del desarrollo eficiente. Cada entorno de desarrollo tiene su propio sistema de gestión de tareas y compilación:\n",
    "\n",
    "- **VS Code**: Usa `tasks.json` para definir tareas de compilación.\n",
    "- **Sublime Text**: Usa archivos `.sublime-build` para compilar programas.\n",
    "- **Makefiles**: Son útiles en proyectos complejos y pueden utilizarse en cualquier editor.\n",
    "- **CMake**: Una herramienta avanzada para proyectos multiplataforma, que puede integrarse con IDEs como **CLion** y **Visual Studio**.\n",
    "- **Visual Studio**: Administra proyectos y soluciones con un potente conjunto de herramientas integradas.\n",
    "\n",
    "Cada plataforma y herramienta tiene sus propias ventajas, pero todas comparten el objetivo de **automatizar y optimizar el flujo de trabajo** del desarrollo de software."
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}