Lab02 SO

UNIVERSIDAD NACIONAL DE SAN AGUSTIN
FACULTAD DE INGENIERÍA DE PRODUCCIÓN Y SERVICIOS

ESCUELA PROFESIONAL DE INGENIERÍA DE SISTEMA
Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Aprobación: 2022/03/01 Código: GUIA-PRLE-001 Página: 1
INFORME DE LABORATORIO
INFORMACIÓN BÁSICA
ASIGNATURA: Laboratorio de Sistemas Operativos - C
TÍTULO DE LA
Programación en C y C++ usando la terminar de Linux
PRÁCTICA:
NÚMERO DE NRO.
02 AÑO LECTIVO: 2023 VI
PRÁCTICA: SEMESTRE:
FECHA DE HORA DE
25/06/2023
PRESENTACIÓN PRESENTACION
ALUMNO:
Llaique Chullunquia Angie Carolina NOTA:
DOCENTE(s):
Apaza Aceituno Roni Guillermo
SOLUCIÓN Y RESULTADOS
I. EJERCICIOS RESUELTOS POR EL DOCENTE
Ejercicio 1.
Escribir el siguiente código en un archivo llamado holamundo.c, dentro de una carpeta con el
siguiente contenido:
#include <stdio.h>
int main ()
{
printf("Hola mundo!\n");
return 0;
}

Después compilarlo con el siguiente comando:

$gcc holamundo.c
Para ejecutar el programa compilado compruebe que se creo el archivo ejecutable. a.out. para
ejecutar, escriba la siguiente línea:
$./a.out
—------------------------------------------------------------------------------------------------------------------------------
Ejercicio 2
Compile el código en el archivo llamado holamundo.c, visto en el ejercicio anterior, con la
siguiente línea:
$gcc -o hola holamundo.c
Para ejecutar el programa compilado compruebe que se creo el archivo ejecutable. hola. para
$./hola

Ejercicio 3
Compile el código en el archivo llamado holamundo.c, visto en el ejercicio anterior, con la
siguiente línea:
$gcc -c holamundo.c
Para verificar que el programa compilado creo el archivo objeto. holamundo.o. utilice el comando
ls para verificar que no se puede ejecutar, escriba la siguiente línea:
$./holamundo.o
—------------------------------------------------------------------------------------------------------------------------------
Ejercicio 4
Escriba el siguiente código en el archivo llamado raiz.c, con el siguiente contenido:
#include <math.h>
#include <stdio.h>
int
main (void)
{
double x = 2.0;
double y = sqrt (x);
printf ("La raíz cuadrada de %f es %f\n", x, y);
return 0;
}

Compilelo siguiendo las siguientes instrucciones:

$gcc -Wall raíz.c -o raiz
Para verificar que el programa compilado creo el archivo objeto. raiz. utilice el comando ls para
verificar que no se puede ejecutar, escriba la siguiente línea:
$./raiz
—------------------------------------------------------------------------------------------------------------------------------
Ejercicio 5
Utilice la opción -lm para compilar el archivo raíz.c usado en el ejercicio anterior para compilar el
código fuente escrito en dicho archivo, usando la siguiente línea de comando:
$gcc -Wall raiz.c -lm -o raiz
verificar que se puede ejecutar, escriba la siguiente línea:

$./raiz
—------------------------------------------------------------------------------------------------------------------------------
Ejercicio 6.
Utilice la opción -lm para compilar el archivo raíz.c usado en el ejercicio anterior para compilar el
código fuente escrito en dicho archivo, usando la siguiente línea de comando:
$gcc -Wall -lm raiz.c -o raiz
verificar que se puede ejecutar, escriba la siguiente línea:
$./raiz
—------------------------------------------------------------------------------------------------------------------------------
Ejercicio 7
Escriba el siguiente código en el archivo llamado malacomp.c, con el siguiente contenido:
#include <stdio.h>
int
main (void)
{
double x = strtod ("123", NULL);
printf ("El valor es %f\n", x);
return 0;
}


$gcc -Wall malacomp.c -o malacomp
Lanzará un mensaje de warning, pero creará un objeto ejecutable. Para verificar que el programa
compilado creo el archivo objeto. malacomp. utilice el comando ls. para verificar que se puede
$./malacomp
—------------------------------------------------------------------------------------------------------------------------------
Ejercicio 8
Escriba el siguiente código en el archivo llamado malacomp.c, con el siguiente contenido:
#include <stdio.h>
#include <stdlib.h>
int main (void)
{
double x = strtod ("123", NULL);
printf ("El valor es %f\n", x);
return 0;
}


$gcc -Wall malacomp.c -o malacomp
Creará un objeto ejecutable. Para verificar que el programa compilado creo el archivo objeto.
malacomp. utilice el comando ls. para verificar que se puede ejecutar, escriba la siguiente línea:
$./malacomp
—------------------------------------------------------------------------------------------------------------------------------
Ejercicio 9
Escriba el siguiente código en el archivo llamado ansi.c, con el siguiente contenido:
#include <stdio.h>
int
main (void)
{
const char asm[] = "6502";
printf ("la cadena asm es '%s'\n", asm);
return 0;
}


$gcc -Wall ansi.c -o ansi
No creará un objeto ejecutable por el error establecido. Para verificar que el programa compilado
no creo el archivo objeto. ansi. utilice el comando ls
—------------------------------------------------------------------------------------------------------------------------------
Ejercicio 10.
Utilizando el código del ejercicio anterior, escriba la siguiente línea para compilarlo:
$gcc -Wall -ansi ansi.c -o ansi
ansi. utilice el comando ls. para verificar que se puede ejecutar, escriba la siguiente línea:
$./ansi
—------------------------------------------------------------------------------------------------------------------------------
Ejercicio 11
Escriba el siguiente código en el archivo llamado pi.c, con el siguiente contenido:
#include <math.h>

#include <stdio.h>
int
main (void)
{
printf ("el valor de pi es %f\n", M_PI);
return 0;
}

$gcc -Wall -ansi pi.c -o pi
No creará un objeto ejecutable por el error establecido. Para verificar que el programa compilado
no creo el archivo objeto. pi. utilice el comando ls.
—------------------------------------------------------------------------------------------------------------------------------
Ejercicio 12
$gcc -Wall pi.c -o pi
Creará un objeto ejecutable. Para verificar que el programa compilado creo el archivo objeto. pi.
utilice el comando ls. para verificar que se puede ejecutar, escriba la siguiente línea:
$./pi

—------------------------------------------------------------------------------------------------------------------------------
Ejercicio 13
$gcc -Wall -ansi -D_GNU_SOURCE pi.c -o pi
Creará un objeto ejecutable. Para verificar que el programa compilado creo el archivo objeto. pi.
utilice el comando ls. para verificar que se puede ejecutar, escriba la siguiente línea:
$./pi
—------------------------------------------------------------------------------------------------------------------------------
Ejercicio 14.
Escriba el siguiente código en el archivo llamado ejemplo.c, con el siguiente contenido:
int
foo (unsigned int x)
{
if (x < 0)
return 0; /* no puede ocurrir */
else
return 1;
}


$gcc -Wall ejemplo.c -o ejemplo
ejemplo. utilice el comando ls. para verificar que se puede ejecutar, escriba la siguiente línea:
$./ejemplo
—------------------------------------------------------------------------------------------------------------------------------
Ejercicio 15
Utilizando el código del anterior ejercicio compílelo siguiendo las siguientes instrucciones, para
obtener más información:
$gcc -W ejemplo.c -o ejemplo
ejemplo. Utilice el comando ls. para verificar que se puede ejecutar, escriba la siguiente línea:
$./ejemplo

Ejercicio 16
Escriba el siguiente código en el archivo llamado conversion.c, con el siguiente contenido:
#include <stdio.h>
#include <stdlib.h>
int
main (void)
{
double x = -3.14;
double y = abs(x); /* debe ser fabs(x) */
printf ("x = %g |x| = %g\n", x, y);
return 0;
}

$gcc -Wall conversion.c -o conversion
conversion. Utilice el comando ls. para verificar que se puede ejecutar, escriba la siguiente línea:
$./conversion

Ejercicio 17.
obtener más
información:
$gcc -W -Wconversion conversion.c -o conversion
Creará un objeto ejecutable, a pesar de la advertencia de Warning. Para verificar que el programa
compilado
creo el archivo objeto. ejemplo. utilice el comando ls. para verificar que se puede ejecutar,
escriba la
siguiente línea:
$./conversion
—------------------------------------------------------------------------------------------------------------------------------
Ejercicio 18
Escriba el siguiente código en el archivo llamado hola.cc, con el siguiente contenido:
#include <iostream>
int
main ()
{
std::cout << "¡Hola, mundo!\n";
return 0;


$g++ -Wall hola.cc -o hola
hola. Utilice el comando ls. para verificar que se puede ejecutar, escriba la siguiente línea:
$./hola
Ejercicio 19
$gcc -Wall hola.cc -o holaC
No creará un objeto ejecutable. Para verificar que el programa compilado no creo el archivo
objeto. Utilice el comando ls.

—------------------------------------------------------------------------------------------------------------------------------
Ejercicio 20
Escriba el siguiente código en el archivo llamado holastr.cc, con el siguiente contenido:
#include <string>
#include <iostream>
using namespace std;
int
main ()
{
string s1 = "¡Hola,";
string s2 = "Mundo!";
cout << s1 + " " + s2 << '\n';
return 0;
}

$g++ -Wall holastr.cc -o holastr

holastr. Utilice el comando ls. para verificar que se puede ejecutar, escriba la siguiente línea:
$./holastr
—---------------------------------------------------------------------------------------------------------------------------
Ejercicio 21
Escriba el siguiente código en el archivo llamado cadena.cc, con el siguiente contenido:
#include <list>
#include <string>
#include <iostream>
int
main ()
{
list<string> list;
list.push_back("Hola");
list.push_back("Mundo");
cout << "List size = " << list.size() << '\n';
return 0;
}


$g++ -Wall cadena.cc -o cadena
cadena. Utilice el comando ls. para verificar que se puede ejecutar, escriba la siguiente línea:
$./cadena
—------------------------------------------------------------------------------------------------------------------------------
Ejercicio 22
Escriba el siguiente código en el archivo llamado buffer.h, con el siguiente contenido:
#ifndef BUFFER_H
#define BUFFER_H
template <class T>
class Buffer
{
public:
Buffer (unsigned int n);

void insert (const T & x);

T get (unsigned int k) const;
private:
unsigned int i;
unsigned int size;
T *pT;
};
template <class T>
Buffer<T>::Buffer (unsigned int n)
{
i = 0;
size = n;
pT = new T[n];
};
template <class T>
void
Buffer<T>::insert (const T & x)
{
i = (i + 1) % size;
pT[i] = x;
};
template <class T>
T
Buffer<T>::get (unsigned int k) const
{
return pT[(i + (size - k)) % size];
};
#endif /* BUFFER_H */

Escriba el siguiente código en el archivo llamado tprog.cc, con el siguiente contenido:

#include <iostream>
#include "buffer.h"

int
main ()
{
Buffer<float> f(10);
f.insert (0.25);
f.insert (1.0 + f.get(0));
cout << "valor almacenado = " << f.get(0) << '\n';
return 0;
}

$g++ -Wall tprog.cc -o tprog
tprog. Utilice el comando ls. para verificar que se puede ejecutar, escriba la siguiente línea:
$./tprog

—------------------------------------------------------------------------------------------------------------------------------
Ejercicio 23
Utilizando el código del ejercicio 18 compílelo siguiendo las siguientes instrucciones, para
$g++ -Wall -march=pentium4 hola.cc -o holaC
objeto. Utilice el comando ls.
—------------------------------------------------------------------------------------------------------------------------------
Ejercicio 24
Utilizando el código del ejercicio 18 compílelo siguiendo las siguientes instrucciones, para
obtener más
información:
$g++ -Wall -march=athlon hola.cc -o holaC
objeto. utilice el comando ls.

II. SOLUCIÓN DE EJERCICIOS PROPUESTOS

Ejercicio 1. Un programa en C que permita hallar el radio de un círculo, usando la palabra clave
define para la constante PI
Ejercicio 2. Crear un programa en C que pida por teclado dos números enteros e imprima en
pantalla su suma, resta, multiplicación, división y el reto (módulo) de la división.


Ejercicio 3. Crear un programa en C que muestre el dato ‘A’ de tipo char y después del número 3
como tipo de dato int, float y double.
III. SOLUCIÓN DEL CUESTIONARIO

1. ¿Describir cuál es la opción para compilar archivos en C++ para procesadores DEC Alpha?
Para compilar archivos en C++ para procesadores DEC Alpha utilizando GCC, se debe utilizar
la opción "-mcpu=alpha". Esta opción indica al compilador que genere código específico para
la arquitectura DEC Alpha [1].
Además de la opción "-mcpu=alpha", también puedes considerar utilizar otras opciones
específicas para optimizar el rendimiento en DEC Alpha, como:
● -mfp-trap-mode=su : Esta opción habilita el modo de trampa de punto flotante, que
permite detectar errores de punto flotante y generar una excepción cuando ocurren.
Esto puede ser útil para identificar problemas de precisión en operaciones de punto
flotante.

● -mieee: Habilita la generación de código que sigue el estándar IEEE para aritmética
de punto flotante. Esto asegura una mayor consistencia en el manejo de números de
punto flotante, pero puede ralentizar el rendimiento en comparación con las
optimizaciones específicas de DEC Alpha.
Es importante tener en cuenta que estas opciones específicas de DEC Alpha pueden variar
según la versión de GCC que estés utilizando y la plataforma en la que estés compilando [2].
2. ¿Cuántos niveles de optimización hay para GCC?
Existen varios niveles de optimización para GCC, y el número de niveles puede variar
dependiendo de cómo se configure el compilador [3]. Los más comunes son:
-O0: No hay optimización.
-O1: Optimiza, pero no invierte demasiado tiempo.
-O2: Optimiza más que -O1.
-O3: Optimiza aún más que -O2, pero puede aumentar significativamente el tiempo de
compilación.
-Os: Optimiza el tamaño del archivo resultante.
-Ofast: Optimiza para aumentar la velocidad de ejecución del código.
Es importante tener en cuenta que cada nivel de optimización puede tener diferentes
conjuntos de optimizaciones habilitadas, y que algunas optimizaciones pueden no ser
seguras en todos los casos. Por lo tanto, es importante compilar y probar el código con
diferentes niveles de optimización para encontrar el equilibrio adecuado entre velocidad y
seguridad [4].
CONCLUSIONES
Programar en C y C++ en la terminal de Linux es una experiencia que proporciona un control sin
igual sobre el sistema y un rendimiento óptimo. Esta combinación de lenguajes de programación
de bajo nivel y un sistema operativo de código abierto como Linux es especialmente valiosa para
aplicaciones de sistemas, donde la eficiencia y la gestión de recursos son esenciales. Linux ofrece
una amplia gama de herramientas de desarrollo y bibliotecas que facilitan la escritura de código
en C y C++, lo que agiliza el proceso de programación.

Además, la curva de aprendizaje de C y C++ puede ser pronunciada para los programadores
novatos, por lo que es importante estar dispuesto a invertir tiempo en su dominio.
En resumen, programar en C y C++ en la terminal de Linux es una elección poderosa para aquellos
que buscan un control total sobre el sistema y un rendimiento óptimo, pero también requiere una
atención meticulosa a la seguridad y una inversión de tiempo en el aprendizaje de estos
lenguajes. Los beneficios son notables en aplicaciones de sistemas y programación de bajo nivel.
REFERENCIAS Y BIBLIOGRAFÍA
[1] “DEC Alpha Options (Using the GNU Compiler Collection (GCC))”. GCC, the GNU Compiler Collection- GNU
Project. Accedido el 21 de septiembre de 2023. [En línea]. Disponible:
https://gcc.gnu.org/onlinedocs/gcc/DEC-Alpha-Options.html
[2] “Hiding in plain sight: The 64bit Dec Alpha C compiler | Virtually Fun”. Virtually Fun | Fun with Virtualization.
Accedido el 21 de septiembre de 2023. [En línea]. Disponible:
https://virtuallyfun.com/2023/05/05/hiding-in-plain-sight-the-64bit-dec-alpha-c-compiler/
[3] “GCC - 3.11 Opciones que controlan la optimización Estas opciones controlan varios tipos de optimizaciones.”
Runebook.dev. Accedido el 21 de septiembre de 2023. [En línea]. Disponible:
https://runebook.dev/es/docs/gcc/optimize-options
[4] “2.4. Optimización del código con GCC Red Hat Enterprise Linux 8 | Red Hat Customer Portal”. Red Hat
Customer Portal. Accedido el 21 de septiembre de 2023. [En línea]. Disponible:
https://access.redhat.com/documentation/es-es/red_hat_enterprise_linux/8/html/developing_c_and_cpp_appli
cations_in_rhel_8/code-optimization-with-gcc_building-code-with-gcc

Lab02 SO

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Lab02 SO

Cargado por

Copyright:

Formatos disponibles

UNIVERSIDAD NACIONAL DE SAN AGUSTIN

FACULTAD DE INGENIERÍA DE PRODUCCIÓN Y SERVICIOS

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Después compilarlo con el siguiente comando:

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Compilelo siguiendo las siguientes instrucciones:

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Compilelo siguiendo las siguientes instrucciones:

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Compilelo siguiendo las siguientes instrucciones:

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Compilelo siguiendo las siguientes instrucciones:

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Compilelo siguiendo las siguientes instrucciones:

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Compilelo siguiendo las siguientes instrucciones:

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Compilelo siguiendo las siguientes instrucciones:

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Compilelo siguiendo las siguientes instrucciones:

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Compilelo siguiendo las siguientes instrucciones:

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Compilelo siguiendo las siguientes instrucciones:

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

void insert (const T & x);

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Escriba el siguiente código en el archivo llamado tprog.cc, con el siguiente contenido:

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Compilelo siguiendo las siguientes instrucciones:

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

II. SOLUCIÓN DE EJERCICIOS PROPUESTOS

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

III. SOLUCIÓN DEL CUESTIONARIO

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

2. ¿Cuántos niveles de optimización hay para GCC?

-O0: No hay optimización.

-O1: Optimiza, pero no invierte demasiado tiempo.

-O2: Optimiza más que -O1.

-Os: Optimiza el tamaño del archivo resultante.

-Ofast: Optimiza para aumentar la velocidad de ejecución del código.

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

También podría gustarte