Unidad 4

Unidad 4 http://linslz.blogspot.mx/search?updated-max=2017-05-15T13:06:00-07:00

Programa Vector

;==========================================================
 ; PROGRAMA : pe26_arr
 ; FUNCION : Vector ingresa datos .
 ; REALIZADO POR : Yesenia Lizbeth Guerrero Garcia
 ; FECHA : jueves 27 abril 2017
 ;=========================================================
title reves.asm

.model small     ;Modelo de memoria m?s utilizado

.stack  256h     ;se define el espacio necesario para la pila

.data
     CR equ 13      ; Constante CR (Retorno de carro) En decimal o
     LF equ 10      ; Constante LF (Salto de l?nea) en hex es igual

     mens db 'Escribe algo y te lo convierto al reves', CR,LF,'$'
     salto db CR,LF,'$'

cadena label byte ;cadena de texto

cant db 20
max  db 00
campo db  20 dup(' ')

 .code

inicio:

 mov ax,@data ; Inicializar correctamente el
 mov ds,ax    ; registro de datos
 push ds      ; Guardar ds en vector
 pop es       ;restaruamos es con sus valores anteriores

 mov ah,09h   ; Esperar tecla
 lea dx,mens  ; CARGA ETIQUETA MENSAJE
 int 21h      ; Llamar a la interrupci?n del DOS

 mov ah,0ah    ; Esperar tecla
 lea dx,cadena ; CARGA ETIQUETA CADENA
 int 21h       ; Llamar a la interrupci?n del DOS

 mov ah,09h    ; Esperar tecla
 lea dx,salto
 int 21h       ; Llamar a la interrupci?n del DOS

 mov cl,cant
 mov bx, offset campo
 add bl, cant

loopo:
  mov dl,[bx] ; Movemos el siguiente caracter ASCII al dl
  mov ah,02h  ;Leer car?cter desde el teclado
  int 21h     ; Llamar a la interrupci?n del DOS
  dec bl
  dec cl
  cmp cl,0
  je salir
  jmp loopo

 salir:
 mov dl,[bx]  ; Movemos el siguiente caracter ASCII al dl
  mov ah,02h  ;Leer car?cter desde el teclado
  int 21h     ; Llamar a la interrupci?n del DOS
 mov ax,4c00h ;regresamos el control al sistema operativo
 int 21h      ; Llamar a la interrupci?n del DOS

 end  inicio

Programa Multiplicación de dos números

;=======================================================
 ; PROGRAMA : pe24_mul
 ; FUNCION : Multimplicacion de dos numeros.
 ; REALIZADO POR : Yesenia Lizbeth Guerrero Garcia
 ; FECHA : jueves 27 abril 2017
 ;======================================================

.model small ;Modelo de memoria m?s utilizado
.stack

.data        ;definici?n de datos(variables), donde se almacenara informaci?n
.code
   chr1  db ?
   chr2  db ?
   chr3  db ?
   r1    db ?
   r2    db ?
   ac    db 0

.startup
   ;cls
   mov ah,00h     ;Function(Set video mode)
   mov al,03      ;Mode 80x25 8x8 16
   int 10h        ;Interruption Video

   mov ah,01h     ;Function(character read)
   int 21h        ;Interruption DOS functions
   sub al,30h     ;ajustamos valores
   mov chr1,al    ;[chr1].chr2 * chr3 = ac.r1.r2
 
   mov ah,01h     ;Function(character read)
   int 21h        ;Interruption DOS functions
   sub al,30h     ;Ajustamos valores
   mov chr2,al    ;chr1.[chr2] * chr3 = ac.r1.r2
 
   mov ah,02h     ;Function(character to send to standard output)
   mov dl,'*'     ;Character to show
   int 21h
 
   mov ah,01h     ;Function(Read character)
   int 21h        ;Interruption DOS Functions
   sub al,30h     ;Transform(0dec = 30hex)
   mov chr3,al    ;chr1.chr2 * [chr3] = ac.r1.r2
 
   mov ah,02h     ;Character to send to standar output
   mov dl,'='     ;
   int 21h        ;Interruption DOS functions
 
   ;Realizamos operaci?n
 
   mov al,chr3    ;al = chr3
   mov bl,chr2    ;bl = chr2
   mul bl         ;AL = chr3*chr2 (BL*AL)
   mov Ah,0h      ;
   AAM            ;ASCII Adjusment
   mov ac,AH      ;ac = AH (Acarreo)
   mov r2,AL      ;r2 = AL       (Unidad del resultado)
 
   mov al,chr3    ;AL = chr3
   mov bl,chr1    ;BL = chr1
   mul bl         ;AL = chr1*chr3 (BL*AL)
   mov r1,al      ;r1 = AL       (Decena del resultado)
   mov bl,ac      ;BL = Acarreo anterior
   add r1,bl      ;r1 = r1+ac (r1 + Acarreo)
   mov ah,00h     ;
   mov al,r1      ;AL = r1 (Asignaci?n para el ajust)
   AAM            ;ASCII Adjustment
   mov r1,al      ;r1 = AL
   mov ac,ah      ;ac = AH (Acarreo para la Centena del resultado)
 
   ;Mostramos resultado
   mov ah,02h  
   mov dl,ac
   add dl,30h
   int 21h        ;Mostramos ac (Centena)

   mov ah,02H
   mov dl,r1
   add dl,30h
   int 21h        ;Mostramos r1 (Decena)

   mov ah,02H
   mov dl,r2
   add dl,30h
   int 21h        ;Mostramos r2 (Unidad)
.exit
end

Programa Suma de dos números

;=========================================================
 ; PROGRAMA : pe22_sum
 ; FUNCION : Suma de dos numeros.
 ; REALIZADO POR : Yesenia Lizbeth Guerrero Garcia
 ; FECHA : jueves 27 abril 2017
 ;========================================================

.model small
.stack 100
.data
msj1 db 'Numero 1: ','$'
msj2 db 13,10,'Numero 2: ','$'
msj3 db 13,10,'Suma: ','$'

msj5 db 13,10,'Multiplicacion: ','$'

linea db 13,10,'$'
var1 db 0
var2 db 0
.code
.startup

call limpia
mov ah,09h
lea dx, msj1 ;desplegar numero 1:
int 21h

call leer ;lee primer numero
sub al,30h ;restar 30h para obtener el numero
mov var1,al ;lo guardo en var1
mov ah,09h
lea dx, msj2 ;desplegar numero 2:
int 21h

call leer ;lee segundo numero
sub al,30h ;restar 30h para obtener segundo valor
mov var2,al ;guardar en var2
mov bl,var2 ;mover a bl

;******************* SUMA
add bl,var1 ; realizo la suma de var2(bl) y var1 y el resultado queda en bl
mov ah,09h
lea dx,msj3 ;imprimir suma
int 21h
mov dl,bl ;pongo en dl el numero a imprimir var2(bl)
add dl,30h ; agrego 30h para obtener el caracter  
mov ah,02h ;imprime un caracter
int 21h



;******************MULTIPLICACION
mov ah,09h
lea dx,msj5 ;desplegar mult
int 21h

mov al,var1
mov bl,var2
mul bl ;mult al=al*bl
mov dl,al ;mover al a dl para imprimir
add dl,30h ;sumar 30 para obtener caracter
mov ah,02h ;imprimir caracter
int 21h


.exit

; ****************PROCEDIMIENTOS
salto proc near
mov ah,09h
lea dx,linea
int 21h
mov dl,00h
ret
salto endp

leer proc near
mov ah,01h;leer caracter desde el teclado
int 21h;lee primer caracter
ret
leer endp

limpia proc near
mov ah,00h
mov al,03h
int 10h
ret
limpia endp
end

Unidad 3 Configuración y administración del espacio en disco

Unidad 3 

http://linslz.blogspot.mx/search?updated-max=2017-05-15T13:06:00-07:00

Unidad III: Modularización

Introducción:

la programación modular es uno de los métodos de diseño mas flexibles y poderosos para el mejoramiento de la productividad de un programa. Usando la programación modular el problema se divide en módulos, donde cada una de los cuales ejecuta una única actividad o tarea y se codifican independientemente de otros modulo.
Cada uno de estos módulos se analiza, se codifica y se prueba de preferencia por separado.
al trabajr conlenguaje ensamblador, la necesidad de la estructura es, si cabe, aún es más vital, puesto que cualquier tarea, por encilla que parezca, puede requerir una gran lista de sentencias ejecutables.
Todo programa contiene un módulo denominado programa principal que controla todo llo que sucede; si se transfiere el control a un submódul, este ejecuta su función y una vez que la termina, regresa el control al módulo desde donde fue llamado. En mucho casos es el modulo principal.
Si la tarea asignada a cada submódulo es demasiado compleja, éste deberá descomponerse en otros módulos más pequeños. Este proceso de descomposición continua hasta que cada módulo tenga una tarea especifica que ejecutar. Esta tarea puede ser:

A) Entreada
B) Salida
C) Manipulación de datos
D) Contro, de otros modulos
E) Alguna combinación de los anteriores

En el lenguaje ENSAMBLADOR esta tecnica se puede llevar a cabo mediante MACROS Y PROCEDIMIENTOS.

3.1 Procedimientos

Es una colección de instrucciones que realizan una tarea específica. Dependiendo
de su extensión y complejidad, un programa puede contener uno, algunos o
inclusive cientos de procedimientos. Para emplear un procedimiento en un
programa se requiere definirlo y llamarlo. Al definir un procedimiento escribimos
las instrucciones que contiene. Al llamar al procedimiento transferimos el fluijo al
procedimiento para que sus instrucciones se ejecuten. Se define como:

PROC nomProc
proposicion
[proposicion]
...
ENDP [nomProc]
La llamada a un procedimiento tiene la siguiente forma:
CALL nomProc
Pra regresar de un procedimiento se utiliza
RET

Un buen procediminto debe:

• Hacer solo una tarea.
• Ser tan pequeño como sea posible y tan largo como sea necesario.
• Contener un comentario con su proposito, datos de entrada y salida.
• Entenderse por si solo.
• Funcionar como lo haría una instrucción del microprocesador.
• No usar variables globales ni para recibir datos, ni regresar un resultado, ni almacenar temporalmente resultados intermedios.

3.2 Macros

Es un conjunto de instrucciones asociadas a un identificador: el nombre de la
macro.
Este conjunto de instrucciones es invocado como una sola instrucción o
macroinstrucción. Para emplear una macro en un programa debemos de definir la
macro e invocar la macro.
La definición de una macro establece el nombre al que se le asocia la macro, el
número y nombre de sus parámetros formales y qué instrucciones contiene la
macroinstrucción. La sintaxis de la definición de una macro es la siguiente:

MACRO nombMacro [parForm[, parForm]...]
proposición
[proposición]
...
ENDM [nombMacro]

Aunque la definición de una macro puede ir en cualquier parte de un programa, el
lugar más recomendable para su localización es al principio de un archivo, antes
de los segmentos de datos y de código.
Al encotrar una invocación de una macro, el macroensamblador substituye la línea
con la invocación por las proposiciones que contiene la definición de la macro.
Este proceso de substitución se conoce como expansión de la macro. La sintaxis
de la invocación de la macro es similar a cualquier instrucción:

nomMacro [parReal[, parReal]...]

donde cada parReal es conocido como un parametro real de la macro. Al
expandirse la macro cada una de las ocurrencias de un parametro formal en la
definición de la macro se substituye por su correspondiente parámetro real.

2.1.1 Estructura de memoria y procesos de la instancia (RESUMEN)

2.1.1 Estructura de memoria y procesos de la instancia

 DBMS

Definición

Es un sistema robusto que es capaz de emplear algoritmos de almacenamiento y recuperación de información para poder implementar un modelo de datos de manera física garantizando que todas las transacciones que se realizan con respecto a dichos datos sean "ácidas" (Atomicity, Consistency, Isolation, Duration).

Para que un DBMS pueda funcionar, primero se debe hacer una instancia de este. Esta instancia está compuesta principalmente de tres componentes:

·         Archivos

·         Estructuras de memoria.

·         Estructuras de procesos.

Cada una de estas estructuras se puede dividir a su vez en diferentes puntos.

Archivos

·         Control (ctl): almacenan información acerca de la estructura de archivos de la base.

·         Rollback (rbs): cuando se modifica el valor de alguna tupla en una transacción, los valores nuevos y anteriores se almacenan en un archivo, de modo que si ocurre algún error, se puede regresar (rollback) a un estado anterior.

·         Redo (rdo): bitácora de toda transacción, en muchos dbms incluye todo tipo de consulta incluyendo aquellas que no modifican los datos.

·         Datos (dbf): el tipo más común, almacena la información que es accesada en la base de datos.

·         Indices (dbf) (dbi): archivos hermanos de los datos para acceso rápido.

·         Temp (tmp): localidades en disco dedicadas a operaciones de ordenamiento o alguna actividad particular que requiera espacio temporal adicional.

Estructura de Memoria

Área Global del sistema (SGA): Es un grupo de estructuras de la memoria compartida que contiene datos e información de control de una instancia de una BD. Si varios usuarios se conectan de forma concurrente a la misma instancia, entonces los datos se comparten en el SGA, por lo que también se llama shared global area.

Estructura de Datos del SGA

·         Caché de los Buffers

·         Buffer del registro de Redo

·         El Pool compartido

·         Large Pool

·         Java Pool

·         Streams Pool

·         Caché de diccionario

Caché de los Buffers (Database Buffer Cache)

Contiene copias de los bloques de datos de lectura de las páginas. Todos los procesos de los usuarios conectados concurrentemente a la instancia comparten el acceso a ella. 

Buffer del registro del Rehacer (Redo Log Buffer)

Contiene información sobre cambios hechos a la base de datos, la cual se almacena en las ‘entradas redo’. Estas entradas contienen la información necesaria para reconstruir, o rehacer cambios hechos en la base de datos mediante las operaciones INSERT, UPDATE, DELETE, CREATE, ALTER o DROP y se usan para la recuperación de la base de datos, si fuera necesario.

El Pool Compartido

Es la parte del SGA que contiene la cache de biblioteca, la cache de diccionario, los buffers para los mensajes de ejecución paralela y las estructuras de control.

Large Pool

El administrador de la base de datos puede configurar un área de memoria opcional llamado large pool que proporciona grandes cantidades de memoria para asignar:

·         Memoria de la sesión para el servidor compartido y el Oracle XA interface (usado donde las transacciones interactúan con más de una base de datos)

·         Procesamiento de E/S

·         Copias de seguridad y operaciones de recuperación

Java Pool

Se usa en la memoria del servidor para almacenar todo el código y datos del JVM en las sesiones.

Streams Pool

En una única base de datos, se puede especificar que los flujos de memoria se asignen desde un pool en el SGA llamado Streams pool.

Cache de diccionario (Dictionary Cache)

El diccionario de datos es una colección de tablas y vistas de la base de datos que contienen información sobre la base de datos (sus estructuras y sus usuarios).

Oracle accede con frecuencia al diccionario de datos, por lo que tiene dos localizaciones especiales en memoria designadas a mantenerlo. Una de ellas es la caché del diccionario de datos, también conocida como la cache de fila por que contiene datos sobre las filas en vez de los buffers (los cuales contienen bloques de datos), y la otra es el cache de biblioteca.

Estructuras de Proceso

Procesos de usuario: Cada proceso de usuario representa la conexión de un usuario al servidor

Procesos de segundo plano: El servidor se vale de una serie de procesos que son el enlace entre las estructuras físicas y de memoria.

·        SMON

·        PMON

·        DBWR

·        LGWR

·        CKPT

·        ARCH

·        RECO

·        LCK

Monitor del sistema (System Monitor, SMON)

Es responsable de efectuar la recuperación de un error cuando se arranca la instancia a continuación de algún tipo de fallo.

Monitor de procesos (Process Monitor, PMON)

Es responsable de controlar los procesos de usuario que accedan a la base de datos y recuperados después de producirse algún error.

Escritor de base de datos (Database Writer, DBWR)

El proceso DBWR es responsable de escribir los bloques modificados (sucio) desde la caché de búfer del SGA a los archivos de datos situados en disco.

Escritor de registro (Log Writer, LGWR)

Es responsable de escribir los datos desde el búfer de registro al archivo de redo.

Punto de control (Checkpoint, CKPT)

Este proceso escribe en los ficheros de control los checkpoints. Estos puntos de sincronización son referencias al estado coherente de todos los ficheros de la BD en un instante determinado, en un punto de sincronización.

Archivador (Archiver, ARCH)

Es responsable de copiar los archivos de registro de rehacer en línea en el soporte de almacenamiento de archivo cuando dichos registros se llenan.

Recuperador (Recoverer, RECO)

Es responsable de efectuar las tareas de limpieza requeridas por las transacciones distribuidas que hayan fallado o que hayan sido suspendidas.