Practica Operativos

INSTITUTO POLITECNICO
NACIONAL
ESCUELA SUPERIOR DE CMPUTO
LABORATORIO DE SISTEMAS
OPERATIVOS
PRCTICA 6:
Comunicacin inter procesos (IPC) en
Linux y Windows
INTEGRANTES:
Aguirre Cruz Eder Jonathan
Buenda Moreno Hugo Vidal
Saules Cortes Jhonatan
MATERIA: Sistemas Operativos
PROFESOR: Cortes Galicia Jorge
GRUPO: 2CM4
FECHA DE ENTREGA: 15 07- 2015
Competencia
El alumno comprende el funcionamiento de las tuberas (pipes) sin nombre y de la
memoria compartida como mecanismos de comunicacin entre procesos utilizando
el intercambio de mensajes tanto en el sistema operativo Linux como Windows.
Desarrollo
Observaciones Individuales
1.- Aguirre Cruz Eder Jonathan
Seccin Linux
1. A travs de la ayuda en lnea que proporciona Linux, investigue el
funcionamiento de la funcin: pipe(),shmget(), shmat(). Explique
los argumentos y retorno de la funcin.
shmget()
La sintaxis de la llamada de sistema shmget() es la siguiente:
shmid = shmget(llave, tamao, bandera);
donde el tamao especifica el nmero de bytes en la regin. El kernel del
sistema operativo busca la llave en la tabla de memoria compartida: si no la
encuentra y la bandera es IPC_CREAT, se crea una nueva regin y regresa
un identificador de tipo entero; si la encuentra, regresa el identificador
correspondiente a la regin de memoria.
shmat()
Un proceso anexa una regin de memoria compartida a su espacio de
direcciones virtuales con la llamada de sistema shmat().
virtaddr = shmat(id, addr, banderas);
id es el identificador de regin de memoria regresado por una llamada anterior
a shmget(), addr es la direccin virtual en donde el usuario desea anexar la
regin de memoria compartida, y banderas especifica las caractersticas de la
regin de memoria. Al ejecutar shmat(), el kernel verifica que el proceso tenga
los permisos necesarios para acceder a la regin. Examina la direccin

provista por el usuario: si es 0, el kernel determina una direccin virtual
conveniente. La memoria compartida no debe traslaparse con las regiones del
espacio de direcciones virtuales. El valor virtaddr regresado por esta llamada
es la direccin en la que el kernel anex la memoria compartida, no
necesariamente la direccin addr especificada por el usuario. virtaddr es un
apuntador genrico (a ningn tipo de dato en especial, implementado en C
comnmente como un apuntador de tipo char), es decir:
char *virtaddr;
Para desasociar la regin de memoria virtual del espacio de direcciones
virtuales, se utiliza la llamada shmdt() como sigue:
shmdt(virtaddr)
2.- Saules Cortes Jhonatan

2. Capture, compile y ejecute el siguiente programa. Observe su funcionamiento
y explique.
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#define VALOR 1
int main (void)
{
int desc_arch[2];
char bufer[100];
if(pipe(desc_arch)!=0)
exit(1);
if(fork()==0)
{
while(VALOR)
{
read(desc_arch[0],bufer,sizeof(bufer));
printf(Se recibi: %s\n, bufer);
}
}
while(VALOR)
{
gets(bufer);
write(desc_arch[1],bufer,strlen(bufer)+1);
}
}
Pantalla de ejecucin
3.- Buendia Moreno Hugo Vidal

3. Capture, compile y ejecute los siguientes programas. Observe su
funcionamiento
y
explique.
Ejecute
de
la
siguiente
forma:
C:\>nombre_programa_padre_hijo
#include <windows.h>
#include <stdio.h>
#include <string.h>
int main(int argc, char *argv[])
{
char mensaje[]=Tuberias en Windows;
DWORD escritos;
HANDLE hLecturaPipe,hEscrituraPipe;
PROCESS_INFORMATION piHijo;
STARTUPINFO siHijo;
SECURITY_ATTRIBUTES pipeSeg = {sizeof(SECURITY_ATTRIBUTES), NULL, TRUE};
/*Obtencin de informacin para la inicializacin del proceso hijo*/
GetStartupInfo(&siHijo);
/*Creacin de la tubera sin nombre*/
CreatePipe(&hLecturaPipe, &hEscrituraPipe, &pipeSeg,0);
/*Escritura en la tubera sin nombre*/
WriteFile(hEscrituraPipe, mensaje, strlen(mensaje)+1, &escritos, NULL);
siHijo.hStdInput = hLecturaPipe;
siHijo.hStdError = GetStdHandle (STD_ERROR_HANDLE);
siHijo.hStdOutput = GetStdHandle (STD_OUTPUT_HANDLE);
siHijo.dwFlags = STARTF_USESTDHANDLES;
CreateProcess(NULL,argv[1],NULL,NULL,TRUE, /*Hereda el proceso hijo los
manejadores de la tubera del padre*/ 0,NULL,NULL,&siHijo,&piHijo);
WaitForSingleObject(piHijo.hProcess,INFINITE);
printf(Mensaje recibido en el proceso hijo, termina el proceso padre\n);
CloseHandle(hLecturaPipe);
CloseHandle(hEscrituraPipe);
CloseHandle(piHijo.hThread);
CloseHandle(piHijo.hProcess);
return 0;
}
/*Programa hijo.c*/
#include <stdio.h>
int main()
{
char mensaje[20];
DWORD leidos;
HANDLE hStdIn = GetStdHandle(STD_INPUT_HANDLE);
SECURITY_ATTRIBUTES pipeSeg = {sizeof(SECURITY_ATTRIBUTES), NULL, TRUE};
/*Lectura desde la tubera sin nombre*/
ReadFile(hStdIn, mensaje, sizeof(mensaje), &leidos, NULL);
printf(Mensaje recibido del proceso padre: %s\n, mensaje);
CloseHandle(hStdIn);
printf(Termina el proceso hijo, continua el proceso padre\n);
return 0;
}
4. Programe una aplicacin que cree un proceso hijo a partir de un proceso

padre, el proceso padre enviar al proceso hijo, a travs de una tubera, dos
matrices de 15 x 15 a multiplicar por parte del hijo, mientras tanto el proceso
hijo crear un hijo de l, al cual enviar dos matrices de 15 x 15 a sumar en el
proceso hijo creado, nuevamente el envo de estos valores ser a travs de
una tubera. Una vez calculado el resultado de la suma, el proceso hijo del
hijo devolver la matriz resultante a su abuelo (va tubera). A su vez, el
proceso hijo devolver la matriz resultante de la multiplicacin que realiz a
su padre. Finalmente, el proceso padre obtendr la matriz inversa de cada
una de las matrices recibidas y el resultado lo guardar en un archivo para
cada matriz inversa obtenida. Programe esta aplicacin tanto para Linux
como para Windows utilizando las tuberas de cada sistema operativo.
Seccin Linux
/*Padre.c*/
#include<stdio.h>
#include<unistd.h>
#include<string.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/wait.h>
void SumaMatrices(int a[][15],int b[]
[15],int r[][15]);
void RestaMatrices(int a[][15],int b[]
[15],int r[][15]);
void MultiplicaMatrices(int a[][15],int
b[][15],int r[][15]);
void TraspuestaMatriz(int a[][15]);
int InversaMatriz(int a[][15], float
matrizDeInversa[][15]);
void ArchPutsMatriz(FILE *Archivo, int
Matriz[][15]);
void ArchPutsMatrizFloat(FILE *Archivo,
float Matriz[][15]);
void ArchImprimeMatriz(FILE *Archivo);
void ArchImprimeContenido(FILE
*Archivo);
int main(int argc, char* argv[]){
//Definiendo las matrices a trabajar
int Matriz1[15][15],Matriz2[15][15];
int MatrizResultado[15][15];
int i,j;
FILE
*ArchMatriz1=fopen("mat1.txt","r");
FILE
if (ArchMatriz1==NULL ||
ArchMatriz2==NULL){
printf("Error al cargar los
archivos\n");
exit(0);
}
//Obtener de los archivos las matrices
for(i=0; i<15; i++){
for(j=0; j<15; j++){
fscanf(ArchMatriz1,"%d",&Matriz1[i]
[j]);
[j]);
}
}
fclose(ArchMatriz1);
//Creando la tuberia
int tuberiaFD[2];
if(pipe(tuberiaFD)!=0)
return 0;
//Agregando valores enteros a carcteres
para los descriptores de la tuberia
char tuberiaFD_read[15];
sprintf(tuberiaFD_read, "%d",
tuberiaFD[0]);
char tuberiaFD_write[15];
sprintf(tuberiaFD_write, "%d",
tuberiaFD[1]);
//Parametros para el hijo
char* argHijo[15];
argHijo[0]="Hijo";
argHijo[1]=tuberiaFD_read;
argHijo[2]=tuberiaFD_write;
argHijo[3]=NULL;
//Creacion del proceso
pid_t pid=fork();
int status;
if(pid == -1)
printf("Error al crear el proceso
\n");
else if(pid == 0)
execv(argHijo[0],argHijo);
else{
write(tuberiaFD[1],Matriz1,sizeof(Matriz
1));
2));
waitpid(pid,&status,0);
//Recuperando matrices devueltas por
la familia
int MatrizSumaResultado[15][15];
int MatrizMultResultado[15][15];
read(tuberiaFD[0],MatrizSumaResultado,
sizeof(MatrizSumaResultado));
read(tuberiaFD[0],MatrizMultResultado,s
izeof(MatrizMultResultado));
//Sacando sus inversas....
float InvMatrizSumaResultado[15]
[15];
float InvMatrizMultResultado[15][15];
FILE
*MatrizInversaPorHijo=fopen("MatrizInv
ersaPorHijo","w");
FILE
*MatrizInversaPorNieto=fopen("MatrizIn
versaPorNieto","w");
if(InversaMatriz(MatrizSumaResultado,
InvMatrizSumaResultado)==1)
ArchPutsMatrizFloat(MatrizInversaPorHijo
,InvMatrizSumaResultado);
else
fprintf(MatrizInversaPorHijo,"No
tiene inversa");
if(InversaMatriz(MatrizMultResultado,
InvMatrizMultResultado)==1)
ArchPutsMatrizFloat(MatrizInversaPorNiet
o,InvMatrizMultResultado);
else
fprintf(MatrizInversaPorNieto,"No
tiene inversa");
return 0;
}
return 0;
}
b[][15],int r[][15]){
int i,j,k;
for(i=0;i<15;i++){
for (j=0;j<15;j++){
r[i][j]=0;
for(k=0;k<15;k++){
r[i][j]+= a[i][k] * b[k][j];
}
}
}
}
matrizDeInversa[][15]){
int i, j, k , terminosIguales=0,
orden=15;
float pivote=0,
matrizDeIdentidad[orden][orden],
dividendo=0;
//Inicializando matriz identidad
for(i=0;i<orden;i++){
for(j=0;j<orden;j++){
if(i==j){
matrizDeInversa[i][j]=1;
}
else{
}
}
}
//Copiar matriz recibida entera en la
flotante
matrizDeIdentidad[i][j]=(float)a[i]
[j];
}
}
//Iniciar el algoritmo de obtener la
inversa por Gauss Jordan
//Volviendola triangular inferior
pivote=matrizDeIdentidad[i][i];
for(j=i;j<orden-1;j++){
dividendo= matrizDeIdentidad[j+1]
[i];
terminosIguales=0;
for(k=0;k<orden;k++){
if(matrizDeIdentidad[j+1]
[k]==matrizDeIdentidad[i][k]){
terminosIguales++;
if(terminosIguales==orden){
return 0;
}
}
matrizDeIdentidad[j+1][k]=(
(pivote/dividendo) *
matrizDeIdentidad[j+1][k] )matrizDeIdentidad[i][k];
matrizDeInversa[j+1][k]=(
matrizDeInversa[j+1][k] )matrizDeInversa[i][k];
}
}
}
//Volviendola triangular superior y asi
volverla una matriz escalar (o puede que
ya de identidad)
for(i=orden-1;0<=i;i--){
for(j=i;0<j;j--){
dividendo= matrizDeIdentidad[j-1]
[i];
for(k=orden-1;0<=k;k--){
matrizDeIdentidad[j-1][k]=(
(dividendo/pivote) *
matrizDeIdentidad[i][k] )matrizDeIdentidad[j-1][k];
matrizDeInversa[j-1][k]=(
(dividendo/pivote) * matrizDeInversa[i]
[k] )- matrizDeInversa[j-1][k];
}
}
}
//Finalmente, la matriz inversa la

volvemos identidad dividiendola si es
escalar
matrizDeInversa[i]
[j]=matrizDeInversa[i]
[j]/matrizDeIdentidad[i][i];
}
}
return 1;
}
Matriz[][15]){
int i,j;
for (i=0;i<15;i++){
for(j=0;j<15;j++){
fprintf(Archivo,"%d ",Matriz [i][j]);
}
fprintf(Archivo,"\n");
}
}
float Matriz[][15]){
int i,j;
for (i=0;i<15;i++){
for(j=0;j<15;j++){
fprintf(Archivo,"%f ",Matriz [i][j]);
}
}
}
void ArchImprimeMatriz(FILE *Archivo){
int i,j,a[15][15];
for(i=0; i<15; i++){
for(j=0; j<15; j++){
fscanf(Archivo,"%d",&a[i][j]);
printf("%d ",a[i][j]);
}
printf("\n");
}
}
*Archivo){
char Caracter;
while(!feof(Archivo)){
fscanf(Archivo,"%c",&Caracter);
printf("%c",Caracter);
}
printf("\n");
}
/*Hijo.c*/
#include<stdio.h>
#include<unistd.h>
#include<string.h>
[15],int r[][15]);
Matriz[][15]);
*Archivo);
//Recuperando valores de tuberia
int tuberiaFD[2];
int i,j;
tuberiaFD[0]=atoi( argv[1] );
//Recuperando la matriz de la tuberia
int Matriz1[15][15];
//Leyendo las matrics a traves de la
tuberia
read(tuberiaFD[0],Matriz1,sizeof(Matriz
1));
2));
//Realizando Operaciones
SumaMatrices(Matriz1,Matriz2,MatrizSu
maResultado);
//Definiendo la matriz a operar

FILE
FILE
ArchMatriz4==NULL){
archivos\n");
exit(0);
}
for(i=0; i<15; i++){
for(j=0; j<15; j++){
[j]);
[j]);
}
}
//Parametros para el hijo
char* argNieto[10];
argNieto[0]="Nieto";
argNieto[1]=argv[1];
argNieto[2]=argv[2];
argNieto[3]=NULL;
//Creacion del proceso
pid_t pid=fork();
int status;
if(pid == -1)
printf("Error al crear el proceso
\n");
else if(pid == 0)
execv(argNieto[0],argNieto);
else{
3));
4));
write(tuberiaFD[1],MatrizSumaResultado
,sizeof(MatrizSumaResultado));
waitpid(pid,&status,0);
}
return 0;
}
[15],int r[][15]){
int i,j;
for (i=0;i<15;i++){
for(j=0;j<15;j++){
r[i][j]=a[i][j] + b[i][j];
}
}
}
Matriz[][15]){
int i,j;
for (i=0;i<15;i++){
for(j=0;j<15;j++){
}
}
}

int i,j;
for (i=0;i<15;i++){
for(j=0;j<15;j++){
}
}
}
int i,j,a[15][15];
for(i=0; i<15; i++){
for(j=0; j<15; j++){
}
printf("\n");
}
}
*Archivo){
char Caracter;
}
printf("\n");
}
/*Nieto.c*/
#include<stdio.h>
#include<unistd.h>
#include<string.h>
Matriz[][15]);
b[][15],int r[][15]);
//Recuperando valores de tuberia
int tuberiaFD[2];
//Recuperando la matriz de la tuberia
//Leyendo las matrics a traves de la
tuberia
3));
4));
FILE
*MatrizMulti=fopen("MatrizMulti","w");
MultiplicaMatrices(Matriz3,Matriz4,Matriz
MultResultado);
write(tuberiaFD[1],MatrizMultResultado,
sizeof(MatrizMultResultado));
ArchPutsMatriz(MatrizMulti,MatrizMultRes
ultado);
return 0;
}
b[][15],int r[][15]){
int i,j,k;
for(i=0;i<15;i++){
for (j=0;j<15;j++){
r[i][j]=0;
for(k=0;k<15;k++){
r[i][j]+= a[i][k] * b[k][j];
}
}
}
}
Matriz[][15]){
int i,j;
for (i=0;i<15;i++){
for(j=0;j<15;j++){
}
}
}

Seccin Windows
Cdigo fuente
#include <stdlib.h>
CreateProcess(NULL,
argv[1],
NULL, NULL, TRUE, 0, NULL, NULL,
&siHijo, &piHijo);
int main(int argc, char *argv[]){

HANDLE hLecturaPipe;
STARTUPINFO siHijo;
WaitForSingleObject(piHijo.hProcess,INFI
NITE);
siHijo.hStdError
=
GetStdHandle(STD_ERROR_HANDLE);
siHijo.hStdOutput
=
GetStdHandle(STD_OUTPUT_HANDLE);
siHijo.dwFlags
=
STARTF_USESTDHANDLES;
system("PAUSE>nul");
return 0;
}
/*Padre.c*/
#include <stdio.h>
#define TAM_MATRIZ 15
int determinanteRecursivo(int **M, int
tam);
void
calcularCofactores(int
**M,int
**M_cofactores, int tam);
void llenarMatrices(int M1[TAM_MATRIZ]
[TAM_MATRIZ], int M2[TAM_MATRIZ]
[TAM_MATRIZ]);
typedef struct Informacion info;
struct Informacion{
int M1[TAM_MATRIZ][TAM_MATRIZ];
HANDLE escritura;
};
argc = 2;
argv[1] = "Hijo.exe";
info argumentos;
int i, j, det;
int multiplicacion[TAM_MATRIZ]
[TAM_MATRIZ];
int suma[TAM_MATRIZ][TAM_MATRIZ];
int **M_inversa1 = NULL;
int **M_cofactores = NULL;
FILE *archivo;
DWORD escritos, leidos, leidos2;
HANDLE
hLecturaPipe,
hEscrituraPipe, nmulti, hEscrituraPipe2,
hLecturaPipe2,
hEscrituraPipe3,
hLecturaPipe3;
STARTUPINFO siHijo;
SECURITY_ATTRIBUTES pipeSeg
=
{sizeof(SECURITY_ATTRIBUTES),NULL,T
RUE};
llenarMatrices(argumentos.M1,argumen
tos.M2);
printf("Matriz 1 para multiplicacin");

for(i = 0; i < TAM_MATRIZ; i++)
{
printf("\n");
for(j = 0; j < TAM_MATRIZ;
j++)
printf("%d ",
argumentos.M1[i][j]);
}
printf("\n\n");
printf("Matriz 2 para multiplicacion");
{
printf("\n");
j++)
printf("%d ",
argumentos.M2[i][j]);
}
printf("\n\n");
CreatePipe(&hLecturaPipe,&hEscrituraPi
pe,&pipeSeg,0);
CreatePipe(&hLecturaPipe2,&hEscritura
Pipe2,&pipeSeg,0);
CreatePipe(&hLecturaPipe3,&hEscritura
Pipe3,&pipeSeg,0);
argumentos.escritura
=
hEscrituraPipe3;
WriteFile(hEscrituraPipe,
&argumentos,
sizeof(argumentos),
&escritos, NULL);
siHijo.hStdError
=
siHijo.hStdOutput
=
hEscrituraPipe2;
siHijo.dwFlags
CreateProcess(NULL,
argv[1],
&siHijo, &piHijo);
ReadFile(hLecturaPipe2,&multiplicaci
on,sizeof(multiplicacion),&leidos,NULL);
printf("Matriz ya multiplicada");
{
printf("\n");
j++)
printf("%d ",
multiplicacion[i][j]);
}
ReadFile(hLecturaPipe3,&suma,sizeof(su
ma),&leidos2,NULL);
printf("\n\n");
printf("Matriz ya sumada");
{
printf("\n");
j++)
printf("%d ", suma[i]
[j]);
}
M_inversa1
=
(int
**)malloc(sizeof(int *) * TAM_MATRIZ);
M_inversa2
=
(int
M_cofactores
=
(int
{
M_inversa1[i]
=
(int
*)malloc(sizeof(int) * TAM_MATRIZ);
M_inversa2[i]
=
(int
M_cofactores[i]
=
(int
}
j++)
{
M_inversa1[i][j] =
multiplicacion[i][j];
M_inversa2[i][j] =
suma[i][j];
}
det
=
determinanteRecursivo(M_inversa1,
TAM_MATRIZ);
if(det == 0) //Si la matriz 1 no
tiene inversa.
{
for(i = 0; i < TAM_MATRIZ;
i++)
for(j = 0; j <
TAM_MATRIZ; j++)
M_inversa1[i][j] = 0;
}
else
{
calcularCofactores(M_inversa1,
M_cofactores, TAM_MATRIZ);
i++)
for(j = 0; j <
TAM_MATRIZ; j++)
{
M_inversa1[i][j]
M_cofactores[j][i];
M_inversa1[i][j] /= det;
}
}
det
=
TAM_MATRIZ);
tiene inversa.

{
free(M_inversa1[i]);
free(M_cofactores[i]);
}
free(M_inversa1);
free(M_inversa2);
free(M_cofactores);

i++)
for(j
0;
<
TAM_MATRIZ; j++)
M_inversa2[i][j] = 0;
}
else
{
printf("\n\nI've done my work");

i++)
for(j = 0; j <
TAM_MATRIZ; j++)
{
M_inversa2[i][j]
M_cofactores[j][i];
M_inversa2[i][j] /= det;
}
}
archivo
fopen("inversa1.txt","w+");

{
fprintf(archivo,"\n");
for(j = 0; j < TAM_MATRIZ; j++)
fprintf(archivo,"%d
", M_inversa1[i][j]);
}
fclose(archivo);
archivo = fopen("inversa2.txt","w+");
{
fprintf(archivo,"%d
}
}
[TAM_MATRIZ],
int M2[TAM_MATRIZ]
[TAM_MATRIZ])
{
int x, y;
srand(time(NULL));
for(x = 0; x < TAM_MATRIZ; x+
+)
for(y
=
0;
y
<
TAM_MATRIZ; y++)
M1[x][y] = rand()
% 21;
+)
for(y
TAM_MATRIZ; y++)
0;
<
M2[x][y] = rand()
% 21;
}
tam)
{
int **M_aux = NULL;
int det = 0, i, j, k, a;
M_aux = (int **)malloc(sizeof(int
*) * (tam - 1));
for(i = 0; i < (tam - 1); i++)

M_aux[i]
=
*)malloc(sizeof(int) * (tam - 1));
int **M_aux;
(int
//Caso base.
if(tam == 2)
{
for(i = 0; i < (tam - 1); i+

*) * (tam - 1));
for(i = 0; i < tam - 1; i++)
M_aux[i]
=
(int
+)
free(M_aux[i]);
free(M_aux);
return M[0][0] * M[1][1] M[0][1] * M[1][0];
}
//Parte recursiva.
for(i = 0; i < tam; i++)
{
for(j = 1; j < tam; j++)
{
a = 0;
for(k = 0; k < tam;
k++)
if(k != i)
for(i = 0; i < tam; i++)

{
for(j = 0; j < tam; j++)
{
a = 0;
for(k = 0; k < tam;
k++)
{
if(k != i)
{
b
0;
for(l
= 0; l < tam; l++)
if(l != j)
M_aux[j - 1][a++] = M[j][k];

}
det
+=
M[0][i]
*
(int)pow(-1.0,
(2
+
i))
*
determinanteRecursivo(M_aux, tam - 1);
}
for(i = 0; i < (tam - 1); i++)
free(M_aux[i]);
free(M_aux);
return det;
M_aux[a][b++] = M[k][l];
a++;
}
}
det
=
M_cofactores[i][j]
= det * (int)pow(-1.0, (i + j + 2));
}
}
}
void calcularCofactores(int **M,
**M_cofactores, int tam)
{
int i, j, k, l, a, b, det = 0;
for(i = 0; i < tam - 1; i++)

free(M_aux[i]);
free(M_aux);
int
}
/*Hijo.c*/
#include <stdio.h>
[TAM_MATRIZ], int M2[TAM_MATRIZ]
[TAM_MATRIZ]);
struct Informacion{
HANDLE nieto;
};
argc = 2;
argv[1] = "Nieto.exe";
info recibido;
info argumentos;
[TAM_MATRIZ];
int i, j;
HANDLE
hLecturaPipe,
hEscrituraPipe;
HANDLE stdOut;
STARTUPINFO siHijo;
DWORD leidos, escritos;
HANDLE
hStdIn
=
GetStdHandle(STD_INPUT_HANDLE);
HANDLE
hStdOut
=
SECURITY_ATTRIBUTES pipeSeg =
{sizeof(SECURITY_ATTRIBUTES), NULL,
TRUE};
ReadFile(hStdIn,&recibido,sizeof(recib
ido),&leidos,NULL);
stdOut = recibido.nieto;
{
j++)
{
multiplicacion[i][j] =
recibido.M1[i][j] * recibido.M2[i][j];
}
}
llenarMatrices(argumentos.M1,argum
entos.M2);
WriteFile(hStdOut, &multiplicacion,
sizeof(multiplicacion), &escritos, NULL);
CreatePipe(&hLecturaPipe,&hEscrituraPi
pe,&pipeSeg,0);
WriteFile(hEscrituraPipe,
&argumentos,
sizeof(argumentos),
&escritos, NULL);
siHijo.hStdError
=
siHijo.hStdOutput = stdOut;
siHijo.dwFlags
=
CreateProcess(NULL,
argv[1],
&siHijo, &piHijo);
WaitForSingleObject(piHijo.hProcess,INFI
NITE);
}
[TAM_MATRIZ],
int M2[TAM_MATRIZ]
[TAM_MATRIZ])
{
int x, y;
srand(time(NULL));
+)
for(y
TAM_MATRIZ; y++)
0;
<

+)
M1[x][y] = rand()
% 25;
for(y
TAM_MATRIZ; y++)
0;
<
M2[x][y] = rand()
% 25;
}
/*Nieto.c*/
#include <stdio.h>
SECURITY_ATTRIBUTES pipeSeg =
{sizeof(SECURITY_ATTRIBUTES), NULL,
TRUE};

struct Informacion{
ReadFile(hStdIn,&recibido,sizeof(recib
ido),&leidos,NULL);
HANDLE padre;
};

{
j++)
{
suma[i][j] = recibido.M1[i][j] +
recibido.M2[i][j];
}
}
int main( ){
info recibido;
int i, j;
HANDLE
hStdOut
=
DWORD leidos, escritos;
HANDLE
hStdIn
=
GetStdHandle(STD_INPUT_HANDLE);
WriteFile(hStdOut,&suma,sizeof(suma
),&escritos,NULL);
}

Seccin Linux
5. Capture, compile y ejecute los siguientes programas para Linux. Observe y
explique su funcionamiento.
#include <sys/types.h> /*Cliente de la memoria compartida*/

#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdio.h>
#define TAM_MEM 27 /*Tamao de la memoria compartida en bytes*/

int main()
{
int shmid;
key_t llave;
char *shm, *s;
llave = 5678;
if((shmid = shmget(llave,TAM_MEM,0666)) <0)(
perror(Error al obtener memoria compartida: shmget);
exit(-1);
}
if((shm = shmat(shmid,NULL,0)) == (char *)-1){
perror(Error al enlazar la memoria compartida: shmat);
exit(-1);
}
for(s = shm; *s!=\0;s++)
putchar(*s);
putchar(\n);
*shm = *;
exit(0);
}
#include <sys/types.h> /*Servidor de la memoria compartida*/
#include <sys/ipc.h> /*(ejecutar el servidor antes de ejecutar al cliente)*/

#include <sys/shm.h>
#include <stdio.h>
int main()
{
int shmid;
key_t llave;
char *shm, *s;
llave = 5678;
if((shmid = shmget(llave,TAM_MEM,IPC_CREAT|0666))<0){
perror(Error al obtener memoria compartida: shmget);
exit(-1);
}
if((shm = shmat(shmat(shmid,NULL,0))==(char *)-1){
perror(Error al enlazar la memoria compartida: shmat);
exit(-1);
}
s = shm;
for(c = a; c<=z; c++)
*s++ = c;
*s = \0;
while(*shm!=*)
sleep (1);
exit(0);
}

Seccin Windows
6. Capture, compile y ejecute los siguientes programas para Windows. Observe
y explique su funcionamiento.
#include <windows.h> /*Cliente de la memoria compartida*/

#include <stdio.h>
int main (void)
{
HANDLE hArchMapeo;
char *idMemCompartida = Memoria Compartida;
char *apDatos, *apTrabajo, c;
if((hArchMapeo=OpenFileMapping(
FILE_MAP_ALL_ACCESS, //acceso lectura/escritura de la memoria compartida
FALSE, //no se hereda el nombre
idMemCompartida) //identificador de la memoria compartida
)==NULL) //
{
printf(No se abri archivo
(%i)\n,GetLastError());
de
mapeo
de
la
memoria
compartida:
exit(-1);
}
if((apDatos=(char *)MapViewOfFile(hArchMapeo, //Manejador del mapeo
FILE_MAP_ALL_ACCESS, //Permiso de lectura/escritura en la memoria
0,
0,
TAM_MEM))==NULL)
{
printf(No se accedi a la memoria compartida: (%i)\n,GetLastError());
CloseHandle(hArchMapeo);
exit(-1);
}
for(apTrabajo = apDatos; *apTrabajo != \0;apTrabajo++)

putchar(*apTrabajo);
putchar(\n);
*apDatos = *;
UnmapViewOfFile(apDatos);
exit(0);
}
#include <windows.h> /*Servidor de la memoria compatida*/

#include <stdio.h>
int main (void)
{
HANDLE hArchMapeo;
char *idMemCompartida = Memoria Compartida;
char *apDatos, *apTrabajo, c;
if((hArchMapeo=CreateFileMapping(
INVALID_HANDLE_VALUE, //usa memoria compartida
NULL, //seguridad por default
PAGE_READWRITE, //acceso lectura/escritura a la memoria
0, //tamao mximo parte alta de un DWORD
TAM_MEM, //tamao mximo parte baja de un DWORD
idMemCompartida) //identificador de la memoria compartida

)==NULL)
{
printf(No se mapeo la memoria compartida: (%i)\n, GetLastError());
exit(-1);
}
if((apDatos=(char *)MapViewOfFile(hArchMapeo, //Manejador del mapeo
FILE_MAP_ALL_ACCESS, //Permiso de lectura/escritura en la memoria
0,
0,
TAM_MEM))==NULL)
{
printf(No se cre la memoria compartida: (%i)\n,GetLastError());
exit(-1);
}
apTrabajo = apDatos;
for(c=a;c<=z;c++)
*apTrabajo++=c;
*apTrabajo=\0;
while(*apDatos !=*)
sleep(1);
exit(0);
}

7. Programe nuevamente el problema del punto cuatro, utilizando en esta
ocasin memoria compartida en lugar de tuberas (utilice tantas memorias
compartidas como requiera). Programe esta aplicacin tanto para Linux como
para Windows utilizando la memoria compartida de cada sistema operativo.
Seccin Linux
/*padre.c*/
#include<stdio.h>
#include<unistd.h>
#include<string.h>
#include<stdlib.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#define MATRIXBYTES 400
/*
Orden de ejecucion:
1.- Padre
2.- Hijo
3.- Nieto
*/
[15],int r[][15]);
void RestaMatrices(int a[][15],int b[]
[15],int r[][15]);
b[][15],int r[][15]);
void TraspuestaMatriz(int a[][15]);
matrizDeInversa[][15]);
Matriz[][15]);

*Archivo);
//Definiendo las matrices a trabajar
int MatrizResultado[15][15];
int i,j;
FILE
FILE
ArchMatriz2==NULL){
archivos\n");
exit(0);
}
for(i=0; i<15; i++){
for(j=0; j<15; j++){
[j]);
[j]);
}
}
//Creando la memoria compartida.
int sharedMemoryID;
key_t llave=1001;
int *shadress, *shauxiliar, *shproceed;
if((sharedMemoryID = shmget(llave,
MATRIXBYTES , IPC_CREAT | 0666)) < 0)
{
perror("Error al obtener la
memoria compartida: shmget");
return -1;
}
if((shadress = shmat(sharedMemoryID,
NULL, 0)) == (int *)-1)
{
perror("Error al enlazar la memoria
compartida: shmat");
return -1;
}
//Agregando los valores a la memoria
compartida
shauxiliar= shadress;
for(i=0; i<15; i++)
{
for(j=0; j<15; j++)
{
*shauxiliar++=Matriz1[i][j];
}
}
shproceed=shauxiliar;
for(i=0; i<15; i++)
{
for(j=0; j<15; j++)
{
}
}
//Declarando arreglos para las
operacion realizadas por la familia
//Esperando a que el nieto acabe su
operacion respectiva
while(*shproceed != '*')
{
sleep(1);
}
//Obteniendo los valores de la
operacion del nieto de la memoria
compartida
for(i=0; i<15; i++)
{
for(j=0; j<15; j++)
{
MatrizMultResultado[i]
[j]=*shauxiliar++;
}
}
//Dandole luz verde al hijo
*shproceed='#';
//Ahora esperando a que el hijo acabe
de colocar su matriz respectiva
while(*shproceed != '*')
{
sleep(1);
}
//Obteniendo los valores de la
operacion del hijo de la memoria
compartida
for(i=0; i<15; i++)
{
for(j=0; j<15; j++)
{
MatrizSumaResultado[i]
[j]=*shauxiliar++;
}
}
//Finalmente, sacando su inversa y
guardandolo en un archivo
float InvMatrizSumaResultado[15][15];
float InvMatrizMultResultado[15][15];
FILE
*MatrizInversaPorHijo=fopen("MatrizInv
ersaPorHijo","w");
FILE
*MatrizInversaPorNieto=fopen("MatrizIn
versaPorNieto","w");
if(InversaMatriz(MatrizSumaResultado,
InvMatrizSumaResultado)==1)
{
ArchPutsMatrizFloat(MatrizInversaPorHijo
,InvMatrizSumaResultado);
}
else
{
fprintf(MatrizInversaPorHijo,"No tiene
inversa");
}
if(InversaMatriz(MatrizMultResultado,
InvMatrizMultResultado)==1)
{
ArchPutsMatrizFloat(MatrizInversaPorNiet
o,InvMatrizMultResultado);
}
else
{
fprintf(MatrizInversaPorNieto,"No
tiene inversa");
}
return 0;
}
b[][15],int r[][15]){
int i,j,k;
for(i=0;i<15;i++){
for (j=0;j<15;j++){
r[i][j]=0;
for(k=0;k<15;k++){
r[i][j]+= a[i][k] * b[k][j];
}
}
}
}
matrizDeInversa[][15]){
int i, j, k , terminosIguales=0,
orden=15;
float pivote=0,
matrizDeIdentidad[orden][orden],
dividendo=0;
//Inicializando matriz identidad
if(i==j){
}
else{
}
}
}
//Copiar matriz recibida entera en la
flotante
matrizDeIdentidad[i][j]=(float)a[i]
[j];
}
}
//Iniciar el algoritmo de obtener la
inversa por Gauss Jordan
//Volviendola triangular inferior
for(j=i;j<orden-1;j++){
dividendo= matrizDeIdentidad[j+1]
[i];
terminosIguales=0;
for(k=0;k<orden;k++){
if(matrizDeIdentidad[j+1]
[k]==matrizDeIdentidad[i][k]){
terminosIguales++;
if(terminosIguales==orden){
return 0;
}
}
matrizDeIdentidad[j+1][k]=(
matrizDeIdentidad[j+1][k] )matrizDeIdentidad[i][k];
matrizDeInversa[j+1][k]=(
matrizDeInversa[j+1][k] )matrizDeInversa[i][k];
}
}
}
//Volviendola triangular superior y asi
volverla una matriz escalar (o puede que
ya de identidad)
for(i=orden-1;0<=i;i--){
for(j=i;0<j;j--){
dividendo= matrizDeIdentidad[j-1]
[i];
for(k=orden-1;0<=k;k--){
matrizDeIdentidad[j-1][k]=(
(dividendo/pivote) *
matrizDeIdentidad[i][k] )-
matrizDeIdentidad[j-1][k];
matrizDeInversa[j-1][k]=(
(dividendo/pivote) * matrizDeInversa[i]
[k] )- matrizDeInversa[j-1][k];
}
}
}
//Finalmente, la matriz inversa la
volvemos identidad dividiendola si es
escalar
matrizDeInversa[i]
[j]=matrizDeInversa[i]
[j]/matrizDeIdentidad[i][i];
}
}
return 1;
}
Matriz[][15]){
int i,j;
for (i=0;i<15;i++){
for(j=0;j<15;j++){
}
}
}

int i,j;
for (i=0;i<15;i++){
for(j=0;j<15;j++){
}
}
}
int i,j,a[15][15];
for(i=0; i<15; i++){
for(j=0; j<15; j++){
}
printf("\n");
}
}
*Archivo){
char Caracter;
}
printf("\n");
}
/*hijo.c*/
#include<stdio.h>
#include<unistd.h>
#include<string.h>
#include<stdlib.h>
#include<sys/ipc.h>
#include<sys/shm.h>
/*
Orden de ejecucion:
1.- Padre
2.- Hijo
3.- Nieto
*/

[15],int r[][15]);
int main(int argc, char* argv[])
{
int sharedMemoryID;
key_t llave=1001;
{
return -1;
}
NULL, 0)) == (int *)-1)
{
return -1;
}
//Obteniendo los valores de la memoria
compartida
int Matriz1[15][15], Matriz2[15][15];
int i,j;
FILE
ILE
ArchMatriz2==NULL){
archivos\n");
exit(0);
}
for(i=0; i<15; i++){
for(j=0; j<15; j++){
[j]);
[j]);
}
}
for(i=0; i<15; i++)
{
for(j=0; j<15; j++)
{
Matriz1[i][j]=*shauxiliar++;
}
}
for(i=0; i<15; i++)
{
for(j=0; j<15; j++)
{
}
}
SumaMatrices(Matriz1,Matriz2,MatrizSu
maResultado);
//Definiendo la matriz a operar
FILE
FILE
ArchMatriz4==NULL){
archivos\n");
exit(0);
}
for(i=0; i<15; i++){
for(j=0; j<15; j++){
[j]);
[j]);
}
}
//Agregando los valores a la memoria
compartida
for(i=0; i<15; i++)
{
for(j=0; j<15; j++)
{
}
}
for(i=0; i<15; i++)
{
for(j=0; j<15; j++)
{
}
}
while(*shproceed != '#')
{
sleep(1);
}
//Agregando los valores de la operacion
respectiva a la memoria compartida

for(i=0; i<15; i++)
{
for(j=0; j<15; j++)
{
*shauxiliar+
+=MatrizSumaResultado[i][j];
}
}
*shproceed='*';
return 0;
}
[15],int r[][15]){
int i,j;
for (i=0;i<15;i++){
for(j=0;j<15;j++){
r[i][j]=a[i][j] + b[i][j];
}
}
}
/*nieto.c*/
#include<stdio.h>
#include<unistd.h>
#include<string.h>
#include<stdlib.h>
#include<sys/ipc.h>
#include<sys/shm.h>
/*
Orden de ejecucion:
1.- Padre
2.- Hijo
3.- Nieto
*/
b[][15],int r[][15]);
int main(int argc, char* argv[])
{
int sharedMemoryID;
key_t llave=1001;
{
return -1;
}
NULL, 0)) == (int *)-1)
{
return -1;
}
//Obteniendo los valores de la memoria
compartida
int Matriz3[15][15], Matriz4[15][15];
int i,j;
for(i=0; i<15; i++)
{
for(j=0; j<15; j++)
{
}
}
for(i=0; i<15; i++)
{
for(j=0; j<15; j++)
{
}
}
MultiplicaMatrices(Matriz3,Matriz4,Matriz
MultResultado);
//Agregando los valores de la operacion
respectiva a la memoria compartida
for(i=0; i<15; i++)

{
for(j=0; j<15; j++)
{
*shauxiliar+
+=MatrizMultResultado[i][j];
}
}
*shproceed='*';
return 0;
}
b[][15],int r[][15]){
int i,j,k;
for(i=0;i<15;i++){
for (j=0;j<15;j++){
r[i][j]=0;
for(k=0;k<15;k++){
r[i][j]+= a[i][k] * b[k][j];
}
}
}
}
3.- Buenda Moreno Hugo Vidal

Seccin Windows
Cdigo fuente
/*cliente.c*/
#include <stdio.h>
#define TAM_MEM 200
#define TAM_MEM2 100
[TAM_MATRIZ],
int
M2[TAM_MATRIZ]
[TAM_MATRIZ]);
int main(void)
{
HANDLE hArchMapeo, hArchMapeo2,
hArchMapeo3;
char *idMemCompartida =
"MemoriaCompartida";
char *idMemCompartida2 =
"MemoriaCompartida2";
char *idMemCompartida3 =
int *apDatos, *apTrabajo, c,
*apDatos2, *apTrabajo2;
int *apDatos3, *apTrabajo3;
int N1[TAM_MATRIZ][TAM_MATRIZ];
int N2[TAM_MATRIZ][TAM_MATRIZ];
[TAM_MATRIZ];
int i = 0, j = 0, com = 0;
llenarMatrices(N1,N2); //Proceso
para enviar datos al Nieto
if((hArchMapeo3 = CreateFileMapping(
INVALID_HANDLE_VALUE,
NULL,
PAGE_READWRITE,
0,
TAM_MEM,
idMemCompartida3)
) == NULL)
{
printf("No se mapeo la
memoria
compartida
(%i)\n",
GetLastError());
exit(-1);
}
if((apDatos3
=
(int*)MapViewOfFile(hArchMapeo3,
FILE_MAP_ALL_ACCESS,
0,
0,
TAM_MEM)) == NULL)
{
printf("No se creo la memoria
compartida: (%i)\n", GetLastError());
CloseHandle(hArchMapeo3);
exit(-1);
}
apTrabajo3 = apDatos3;
{
j++)
*apTrabajo3++ = N1[i]
[j];
}
{
j++)
*apTrabajo3++ = N2[i]
[j];
}
*apTrabajo3 = 599;
while(*apDatos3 != 600)
sleep(1);
UnmapViewOfFile(apDatos3);
if((hArchMapeo = OpenFileMapping(
FALSE,
idMemCompartida)
)== NULL)
{
printf("No se abrio archivo de
mapeo de la memoria compartida:
(%i)\n",GetLastError());
exit(-1);
}
if((apDatos
=
(int*)
MapViewOfFile(hArchMapeo,
0,
0,
TAM_MEM)) == NULL)
{
printf("No se accedio a la
memoria
compartida:
exit(-1);
}
i = 0;
j = 0;
com = 0;
for(apTrabajo = apDatos; *apTrabajo !
= 29; apTrabajo++)
{
if(i == 9 && j == 10)
{
com = 1;
j = 0;
i = 0;
}
if(com == 0)
{
if(j == 10)
{
i++;
j = 0;
}
M1[i][j] = *apTrabajo;
j++;
}
else if(com != 0)
{
if(j == 10)
{
i++;
j = 0;
}
M2[i][j] = *apTrabajo;
j++;
}
}

j++)
printf("%d ",M1[i][j]);
}
printf("\n\n");
{
printf("\n");
j++)
}
putchar('\n');
*apDatos = 30;
{
j++)
multiplicacion[i][j] =
M1[i][j] * M2[i][j];
}
//Envia datos de multiplicacion al
padre
if((hArchMapeo2 = CreateFileMapping(
NULL,
PAGE_READWRITE,
0,
TAM_MEM2,
idMemCompartida2)
) == NULL)
{
memoria
compartida
(%i)\n",
GetLastError());
exit(-1);
}
if((apDatos2
=
(int*)MapViewOfFile(hArchMapeo,

{
printf("\n");
0,
0,
*apTrabajo2 = 499;
TAM_MEM2)) == NULL)
sleep(1);
{
exit(-1);
}

{
j++)
*apTrabajo2++ =
}
exit(0);
}
[TAM_MATRIZ],
int
M2[TAM_MATRIZ]
[TAM_MATRIZ])
{
int x, y;
srand(time(NULL));
for(x = 0; x < TAM_MATRIZ; x++)
for(y
=
0;
y
<
TAM_MATRIZ; y++)
M1[x][y] = rand() %
21;
for(y
=
0;
y
<
TAM_MATRIZ; y++)
M2[x][y] = rand() %
21
/*Servidor.c*/
#include <stdio.h>
#define TAM_MEM 200

[TAM_MATRIZ],
int
M2[TAM_MATRIZ]
[TAM_MATRIZ]);
void
calcularCofactores(int
**M_cofactores, int tam);
**M,int

[TAM_MATRIZ],
int
M2[TAM_MATRIZ]
[TAM_MATRIZ]);
int main(void)
{
if((hArchMapeo = CreateFileMapping(
HANDLE hArchMapeo, hArchMapeo2,

hArchMapeo3;
NULL,
char *idMemCompartida
"MemoriaCompartida";
char *idMemCompartida2
int *apDatos, *apTrabajo,

c,
PAGE_READWRITE,
0,
TAM_MEM,
idMemCompartida)
int *apDatos4, *apTrabajo4;

int i, j, det;
int M1 [TAM_MATRIZ][TAM_MATRIZ];
) == NULL)
{
memoria
GetLastError());
exit(-1);
int M2 [TAM_MATRIZ][TAM_MATRIZ];
[TAM_MATRIZ];
compartida
(%i)\n",
}
if((apDatos
(int*)MapViewOfFile(hArchMapeo,
0,
0,
int **M_cofactores = NULL;
TAM_MEM)) == NULL)
FILE *archivo;
{
llenarMatrices(M1,M2);

exit(-1);
}
if((hArchMapeo2 = OpenFileMapping(
apTrabajo = apDatos;
FALSE,
idMemCompartida2)
)== NULL)
j++)
*apTrabajo++ = M1[i]
[j];
{
exit(-1);
}
if((apDatos2
(int*)
{
j++)
0,
*apTrabajo++ = M2[i]
0,
[j];
TAM_MEM2)) == NULL)
}
{
*apTrabajo = 29;
while(*apDatos != 30)
memoria
compartida:
sleep(1);
exit(-1);

j++)
i = 0;
printf("%d
",multiplicacion[i][j]);
j = 0;
for(apTrabajo2 = apDatos2;
*apTrabajo2 != 499; apTrabajo2++)
}
printf("\n\n");
{
//Obtener iformacin de la suma
if(j == 10)
if((hArchMapeo3 = OpenFileMapping(
{
i++;
FALSE,
j = 0;
idMemCompartida4)
}
)== NULL)
multiplicacion[i][j] = *apTrabajo2;
{
j++;
}
putchar('\n');
exit(-1);
*apDatos2 = 500;
}
if((apDatos4
=
MapViewOfFile(hArchMapeo3,
0,
0,
TAM_MEM2)) == NULL)
printf("\n");
{
(int*)
memoria
compartida:

{
printf("\n");
exit(-1);

j++)
}
printf("%d ",suma[i][j]);
i = 0;
}
j = 0;
//Calculo de las matrices inversas
M_inversa1 = (int **)malloc(sizeof(int

*) * TAM_MATRIZ);
{
if(j == 10)
{
M_inversa2
=
(int
M_cofactores
=
(int
i++;
j = 0;
{
}
suma[i][j] = *apTrabajo4;
j++;
}
putchar('\n');
M_inversa1[i]
=
(int
M_inversa2[i]
=
(int
M_cofactores[i]
=
(int
*apDatos4 = 700;

j++)
{
M_inversa1[i][j]
M_inversa1[i]
[j] = M_cofactores[j][i];
M_inversa2[i][j]
suma[i][j];
M_inversa1[i]
[j] /= det;
det
TAM_MATRIZ);

tiene inversa.
{
i++)
for(j
0;
det
TAM_MATRIZ);

tiene inversa.
{
<
TAM_MATRIZ; j++)

M_inversa1[i]
i++)
[j] = 0;
for(j
0;
<
TAM_MATRIZ; j++)
M_inversa2[i]
else
[j] = 0;
}
else

i++)
for(j
0;
<
TAM_MATRIZ; j++)

{
i++)
for(j
TAM_MATRIZ; j++)
0;
<
M_inversa2[i]
[j] = M_cofactores[j][i];
fprintf(archivo,"%d
M_inversa2[i]
[j] /= det;
}
}
}
//Crea los archivos txt

archivo
fopen("inversa1.txt","w+");
free(M_cofactores[i]);
free(M_inversa1);
free(M_inversa2);
fprintf(archivo,"%d
free(M_cofactores);
}
getchar();
exit(0);
fclose(archivo);
archivo = fopen("inversa2.txt","w+");

[TAM_MATRIZ],
int
M2[TAM_MATRIZ]
[TAM_MATRIZ])
{
{
int x, y;
srand(time(NULL));
//Caso base.
if(tam == 2)
for(y
TAM_MATRIZ; y++)
0;
<
M1[x][y] = rand() %
21;
{
for(i = 0; i < (tam - 1); i+
+)
free(M_aux[i]);
free(M_aux);

for(y
TAM_MATRIZ; y++)
0;
<
return M[0][0] * M[1][1] M[0][1] * M[1][0];

}
M2[x][y] = rand() %
21;
//Parte recursiva.
for(i = 0; i < tam; i++)

{

tam)
for(j = 1; j < tam; j++)

{
a = 0;
int **M_aux = NULL;
for(k = 0; k < tam;
int det = 0, i, j, k, a;
k++)
if(k != i)

*) * (tam - 1));
for(i = 0; i < (tam - 1); i++)
M_aux[i]
=
M_aux[j - 1][a++] = M[j][k];

}
(int
det += M[0][i] * (int)pow(1.0,

(2
+
i))
*
for(j = 0; j < tam; j++)

{
a = 0;
for(k = 0; k < tam;
k++)
for(i = 0; i < (tam - 1); i++)

{
free(M_aux[i]);
if(k != i)
free(M_aux);
{
return det;
b = 0;
}
for(l
= 0; l < tam; l++)
void calcularCofactores(int
**M_cofactores, int tam)
**M,
int
if(l != j)
{
M_aux[a][b++] = M[k][l];
int i, j, k, l, a, b, det = 0;
a++;
int **M_aux;
}
}
*) * (tam - 1));
det
=
for(i = 0; i < tam - 1; i++)

M_aux[i]
=
(int
M_cofactores[i][j] =
det * (int)pow(-1.0, (i + j + 2));
}
for(i = 0; i < tam; i++)

{
for(i = 0; i < tam - 1; i++)
free(M_aux);
free(M_aux[i]);
/*Nieto.c*/
if((hArchMapeo = OpenFileMapping(
#include <stdio.h>
#define TAM_MEM 200
FALSE,
idMemCompartida3)
)== NULL)
{
int main(void)

exit(-1);
HANDLE hArchMapeo, hArchMapeo2;

if((apDatos3
(int*)
int *apDatos3,
*apTrabajo3,
0,
0,
TAM_MEM)) == NULL)
int i = 0, j = 0, com = 0;
{
memoria
compartida:
exit(-1);
else if(com != 0)
i = 0;
j = 0;
if(j == 10)
com = 0;
i++;
j = 0;
{
}
if(i == 9 && j == 10)
M2[i][j] = *apTrabajo3;
{
j++;
com = 1;
}
j = 0;
}
i = 0;
}
if(com == 0)

{
printf("\n");
if(j == 10)
j++)
i++;
j = 0;
printf("\n\n");
M1[i][j] = *apTrabajo3;
j++;
printf("\n");
NULL,
j++)
PAGE_READWRITE,
0,
}
TAM_MEM2,
idMemCompartida4)
) == NULL)
{
{
memoria
compartida
(%i)\n",
GetLastError());
j++)
{
exit(-1);
suma[i][j] = M1[i][j] +
M2[i][j];
}
}
if((apDatos2
(int*)MapViewOfFile(hArchMapeo2,
*apDatos3 = 600;
0,
0,
TAM_MEM2)) == NULL)
{
//Comparte datos con el padre
if((hArchMapeo2
CreateFileMapping(
exit(-1);
*apTrabajo2 = 699;
sleep(1);
j++)
exit(0);
*apTrabajo2++ =
suma[i][j];
}

Practica Operativos

Cargado por

Información del documento

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

Practica Operativos

Cargado por

Copyright:

Formatos disponibles

INSTITUTO POLITECNICO

los permisos necesarios para acceder a la regin. Examina la direccin

2.- Saules Cortes Jhonatan

3.- Buendia Moreno Hugo Vidal

2.- Saules Cortes Jhonatan

4. Programe una aplicacin que cree un proceso hijo a partir de un proceso

//Finalmente, la matriz inversa la

//Definiendo la matriz a operar

void ArchPutsMatrizFloat(FILE *Archivo,

1.- Aguirre Cruz Eder Jonathan

int main(int argc, char *argv[]){

printf("Matriz 1 para multiplicacin");

for(i = 0; i < TAM_MATRIZ; i++)

for(i = 0; i < TAM_MATRIZ;

printf("\n\nI've done my work");

for(i = 0; i < TAM_MATRIZ; i++)

for(i = 0; i < (tam - 1); i++)

M_aux = (int **)malloc(sizeof(int

for(i = 0; i < tam; i++)

M_aux[j - 1][a++] = M[j][k];

for(i = 0; i < tam - 1; i++)

for(x = 0; x < TAM_MATRIZ; x+

typedef struct Informacion info;

for(i = 0; i < TAM_MATRIZ; i++)

2.- Saules Cortes Jhonatan

#include <sys/types.h> /*Cliente de la memoria compartida*/

#define TAM_MEM 27 /*Tamao de la memoria compartida en bytes*/

#include <sys/types.h> /*Servidor de la memoria compartida*/

#include <sys/ipc.h> /*(ejecutar el servidor antes de ejecutar al cliente)*/

1.- Aguirre Cruz Eder Jonathan

#include <windows.h> /*Cliente de la memoria compartida*/

for(apTrabajo = apDatos; *apTrabajo != \0;apTrabajo++)

#include <windows.h> /*Servidor de la memoria compatida*/

idMemCompartida) //identificador de la memoria compartida

2.- Saules Cortes Jhonatan

void ArchPutsMatrizFloat(FILE *Archivo,

void ArchPutsMatrizFloat(FILE *Archivo,

void SumaMatrices(int a[][15],int b[]

respectiva a la memoria compartida

void MultiplicaMatrices(int a[][15],int

for(i=0; i<15; i++)

3.- Buenda Moreno Hugo Vidal

for(j = 0; j < TAM_MATRIZ;

for(i = 0; i < TAM_MATRIZ; i++)

for(i = 0; i < TAM_MATRIZ; i++)

void llenarMatrices(int M1[TAM_MATRIZ]

void llenarMatrices(int M1[TAM_MATRIZ]

HANDLE hArchMapeo, hArchMapeo2,

int *apDatos, *apTrabajo,

int *apDatos4, *apTrabajo4;

int **M_inversa1 = NULL;

int **M_inversa2 = NULL;

int **M_cofactores = NULL;

printf("No se creo la memoria

for(i = 0; i < TAM_MATRIZ; i++)

for(i = 0; i < TAM_MATRIZ; i++)

for(j = 0; j < TAM_MATRIZ;

for(i = 0; i < TAM_MATRIZ; i++)

for(i = 0; i < TAM_MATRIZ; i++)

for(j = 0; j < TAM_MATRIZ;

M_inversa1 = (int **)malloc(sizeof(int

for(i = 0; i < TAM_MATRIZ; i++)

for(j = 0; j < TAM_MATRIZ;

if(det == 0) //Si la matriz 1 no

#include <sys/types.h> /Cliente de la memoria compartida/

#define TAM_MEM 27 /Tamao de la memoria compartida en bytes/

#include <sys/types.h> /Servidor de la memoria compartida/

#include <sys/ipc.h> /(ejecutar el servidor antes de ejecutar al cliente)/

#include <windows.h> /Cliente de la memoria compartida/

#include <windows.h> /Servidor de la memoria compatida/

int apDatos, apTrabajo,

int apDatos4, apTrabajo4;