Este documento describe un programa implementado en Java que utiliza el método de partición fija de memoria. El programa tiene una interfaz que permite al usuario ingresar el número de particiones y procesos, y asigna los procesos a las particiones usando los algoritmos de primer ajuste, mejor ajuste y peor ajuste. El programa dibuja la memoria mostrando qué proceso está asignado a qué partición.
El documento describe la clase Swing en Java. Swing provee componentes gráficos como botones y tablas. Swing hereda el manejo de eventos de AWT. El documento también describe controles Swing básicos como JLabel, JTextField y JButton, explicando cómo crearlos e incluirlos en una ventana. Finalmente, explica el uso de JOptionPane para ingresar y mostrar datos sin usar un formulario.
El documento describe diferentes estructuras de control repetitivas o iterativas en Java, incluyendo bucles while, for y do while. Estos bucles permiten ejecutar código de forma repetida mientras se cumpla una condición. Se proveen ejemplos de cómo calcular tablas de multiplicar, sumatorias y factoriales usando estos bucles.
Este documento describe el desarrollo de un programa en Java para realizar operaciones con números complejos. Los estudiantes declaran variables, asignan valores a botones para diferentes operaciones como suma, multiplicación, potenciación y raíz cuadrada, y desarrollan métodos para calcular dichas operaciones utilizando fórmulas matemáticas. El programa permite representar números complejos en forma cartesiana, polar y exponencial.
Los programas enseñaron cómo implementar interfaces en Java usando eventos. Se crearon dos botones que muestran mensajes diferentes y una calculadora básica. Para crear la interfaz gráfica se usó la clase Frame que genera una ventana y da herramientas para agregar botones y campos de texto. También se usaron listeners para enlazar la interfaz con el código y detectar las acciones del usuario. Aunque las interfaces simplifican el uso para los usuarios, complican la programación al requerir diseño e implementación de acciones.
Este documento presenta 5 ejercicios de programación en Java que incluyen: 1) realizar operaciones matemáticas básicas, 2) determinar si un día es laboral o no, 3) pedir un número y validar que sea mayor a cero, 4) calcular el vuelto de una cantidad de dinero, y 5) hallar el número máximo y mínimo entre tres números ingresados. Los ejercicios están destinados a practicar conceptos básicos de programación para estudiantes de la carrera de Computación e Informática.
Este documento contiene 29 ejercicios de programación en Java sobre diferentes temas como: operaciones con números, estructuras de control, funciones matemáticas, series numéricas, etc. Los ejercicios van desde implementar programas sencillos que realicen cálculos elementales hasta desarrollar algoritmos más complejos basados en métodos numéricos.
El objetivo de esta práctica es aplicar de forma integral los aspectos básicos de flash en una aplicación web, realizada totalmente en flash(ActionScript), que permite clasificar y acceder a una serie de prácticas resueltas relacionadas con materias informáticas. En esta práctica se utilizan componentes (Accordion, Button, ProgressBar, RadioButton, ScrollPane, Tree, MediaDisplay, MediaController, Window,…), loadMovie, #include (.as), import (class), clips de película, audio y video, capas máscara y guía, etc.
Este documento presenta dos prácticas de programación con eventos en Java. La primera práctica crea una calculadora simple con botones numéricos y de operación que realizan cálculos básicos al hacer clic. La segunda práctica crea una ventana con botones "Hola" y "Adiós" que actualizan un campo de texto al hacer clic para mostrar los saludos correspondientes. Ambas prácticas ilustran cómo agregar interactividad a interfaces gráficas mediante el uso de eventos de mouse en respuesta a las acciones del usuario.
El documento describe la clase Swing en Java. Swing provee componentes gráficos como botones y tablas. Swing hereda el manejo de eventos de AWT. El documento también describe controles Swing básicos como JLabel, JTextField y JButton, explicando cómo crearlos e incluirlos en una ventana. Finalmente, explica el uso de JOptionPane para ingresar y mostrar datos sin usar un formulario.
El documento describe diferentes estructuras de control repetitivas o iterativas en Java, incluyendo bucles while, for y do while. Estos bucles permiten ejecutar código de forma repetida mientras se cumpla una condición. Se proveen ejemplos de cómo calcular tablas de multiplicar, sumatorias y factoriales usando estos bucles.
Este documento describe el desarrollo de un programa en Java para realizar operaciones con números complejos. Los estudiantes declaran variables, asignan valores a botones para diferentes operaciones como suma, multiplicación, potenciación y raíz cuadrada, y desarrollan métodos para calcular dichas operaciones utilizando fórmulas matemáticas. El programa permite representar números complejos en forma cartesiana, polar y exponencial.
Los programas enseñaron cómo implementar interfaces en Java usando eventos. Se crearon dos botones que muestran mensajes diferentes y una calculadora básica. Para crear la interfaz gráfica se usó la clase Frame que genera una ventana y da herramientas para agregar botones y campos de texto. También se usaron listeners para enlazar la interfaz con el código y detectar las acciones del usuario. Aunque las interfaces simplifican el uso para los usuarios, complican la programación al requerir diseño e implementación de acciones.
Este documento presenta 5 ejercicios de programación en Java que incluyen: 1) realizar operaciones matemáticas básicas, 2) determinar si un día es laboral o no, 3) pedir un número y validar que sea mayor a cero, 4) calcular el vuelto de una cantidad de dinero, y 5) hallar el número máximo y mínimo entre tres números ingresados. Los ejercicios están destinados a practicar conceptos básicos de programación para estudiantes de la carrera de Computación e Informática.
Este documento contiene 29 ejercicios de programación en Java sobre diferentes temas como: operaciones con números, estructuras de control, funciones matemáticas, series numéricas, etc. Los ejercicios van desde implementar programas sencillos que realicen cálculos elementales hasta desarrollar algoritmos más complejos basados en métodos numéricos.
El objetivo de esta práctica es aplicar de forma integral los aspectos básicos de flash en una aplicación web, realizada totalmente en flash(ActionScript), que permite clasificar y acceder a una serie de prácticas resueltas relacionadas con materias informáticas. En esta práctica se utilizan componentes (Accordion, Button, ProgressBar, RadioButton, ScrollPane, Tree, MediaDisplay, MediaController, Window,…), loadMovie, #include (.as), import (class), clips de película, audio y video, capas máscara y guía, etc.
Este documento presenta dos prácticas de programación con eventos en Java. La primera práctica crea una calculadora simple con botones numéricos y de operación que realizan cálculos básicos al hacer clic. La segunda práctica crea una ventana con botones "Hola" y "Adiós" que actualizan un campo de texto al hacer clic para mostrar los saludos correspondientes. Ambas prácticas ilustran cómo agregar interactividad a interfaces gráficas mediante el uso de eventos de mouse en respuesta a las acciones del usuario.
Este documento presenta un tutorial sobre el uso del lenguaje de programación GNU Octave. Introduce Octave como un programa multiplataforma de código abierto para cálculos numéricos, similar a MATLAB. Explica conceptos básicos como variables, operadores, matrices y vectores. También cubre funciones matemáticas predefinidas, y define funciones y cadenas de caracteres. El objetivo es familiarizar a los estudiantes con la sintaxis básica de Octave para que puedan realizar trabajos prácticos.
Este documento describe los pasos para compilar un programa Java creado en NetBeans. Primero, se verifica que Java esté instalado correctamente. Luego, se crea y guarda el programa en NetBeans y se edita el archivo Java para remover una línea de código. Después, se compila el programa usando el comando "javac" en la terminal para crear una clase, y finalmente se ejecuta usando "java".
Este documento contiene una lista de comandos y sentencias de Java. Entre los comandos se encuentran JFrame para crear ventanas, JButton para colocar botones, y SetSize() para determinar el tamaño de la ventana. También incluye sentencias como if para estructuras condicionales, y operadores lógicos como && y || para formar condiciones compuestas. El documento proporciona ejemplos de cómo utilizar estos comandos y sentencias para realizar tareas comunes en Java.
Este documento presenta un resumen de comandos y conceptos básicos de Java. Incluye instrucciones para crear ventanas, botones, establecer tamaños y títulos. También explica cómo manejar cadenas, fechas, excepciones, herencia y estructuras condicionales if-else. El objetivo es introducir conceptos de programación orientada a objetos utilizando el lenguaje Java.
Este documento describe las interfaces gráficas de usuario en Java. Introduce los conceptos de AWT y Swing, los cuales son las APIs para crear interfaces gráficas en Java. Explica las diferencias entre AWT y Swing, y describe los componentes principales utilizados para crear ventanas y añadir elementos gráficos como botones y etiquetas. También cubre los diferentes gestores de posicionamiento como FlowLayout, BorderLayout y GridLayout para organizar los componentes.
El documento presenta una introducción a MATLAB. Explica que MATLAB es un programa para realizar cálculos numéricos con vectores y matrices y que cuenta con un lenguaje de programación propio. Describe algunas de las características principales de MATLAB como su entorno de operación, los comandos más útiles y ejemplos de prácticas en clase para familiarizarse con el software.
Los documentos presentan 5 ejemplos de programas en Java y NetBeans. El primero suma números ingresados por el usuario hasta que se ingrese 25. El segundo encuentra el número del medio entre tres ingresados hasta que su suma sea 15. El tercero calcula el MCD entre tres números hasta que sea mayor a 10. El cuarto calcula áreas (cuadrado, triángulo, rectángulo y círculo). El quinto genera dos números aleatorios, compara y suma sus valores, los eleva y calcula su raíz cuadrada hasta que esta sea mayor a 4.
Este documento contiene 18 ejercicios de programación en Java con sus respectivas soluciones. Cada ejercicio realiza un cálculo o conversión diferente, como calcular el área de una esfera, convertir grados Celsius a Fahrenheit, o calcular el costo de producción de un artículo. El documento guía al usuario a través de un menú para seleccionar qué ejercicio desea ejecutar.
Conceptos básicos sobre funciones en C: que son, para qué sirven, cómo declararlas, cómo implementarlas, cómo pasar parámetros tanto por valor como por referencia, etc
El documento explica las funciones en programación. Indica que las funciones son grupos de sentencias con un nombre que realizan una tarea específica. También describe cómo se declaran, implementan y usan las funciones, incluyendo conceptos como parámetros, variables locales y tipos de retorno. Finalmente, menciona otros temas relacionados como procedimientos y el paso de parámetros por valor y referencia.
El documento describe diferentes estructuras de control de flujo en Java, incluyendo switch, while, do-while y sus usos. Explica cada estructura con ejemplos de código y diagrama de flujo. Luego presenta 16 ejemplos de aplicación que utilizan estas estructuras para resolver problemas como mostrar tablas de multiplicar, números pares/impares, factoriales y más.
El documento describe la creación de una calculadora básica en Java usando interfaz gráfica de usuario. Se importan las clases necesarias y se crea una clase Main que extiende JFrame e implementa ActionListener. El constructor crea la interfaz con botones y un cuadro de texto usando paneles y eventos de click. El método actionPerformed captura los clicks y determina la acción según el botón presionado para realizar cálculos o limpiar.
Este documento explica el concepto y uso de funciones en Java. Detalla cómo crear funciones con tipos de retorno y parámetros, cómo pasar valores y referencias a funciones, y el uso de la cláusula return. También cubre funciones recursivas que se llaman a sí mismas de forma iterativa o recursiva, como un ejemplo de factorial.
Este documento contiene información sobre subprogramas y funciones en C++. Explica las razones para crear subprogramas, como dividir la complejidad del código y promover la reutilización. También describe los pasos para escribir un subprograma, como definir el problema, darle un nombre y decidir cómo probarlo. Además, cubre temas como los parámetros, el paso de parámetros, el ámbito de variables y la recursividad. Finalmente, incluye ejercicios prácticos sobre el uso de subprogramas.
El documento presenta el código de tres métodos de ordenamiento de datos (burbuja, quicksort y shell) y explica su funcionamiento. Incluye programas que permiten al usuario ingresar datos y ordenarlos usando estos métodos. El autor concluye que aprendió a organizar y facilitar procesos complejos a través del uso de funciones en los programas.
Este documento presenta un examen de microcontroladores de 20 preguntas con opciones múltiples. El examen cubre temas como lazos, arreglos, conversión analógico-digital, comunicación serial y programación en C de PIC. Se pide a los estudiantes marcar la respuesta correcta para cada pregunta en una tabla de respuestas al final.
1) El documento describe los elementos básicos de la estructura de un programa en Java, incluyendo la entrada de datos, procesamiento y salida de resultados. 2) Explica cómo leer datos de entrada del usuario y mostrar resultados, así como diferentes formas de estructurar y documentar el código de manera clara. 3) Incluye ejemplos de programas sencillos que ilustran estos conceptos.
Este documento presenta un tutorial sobre el uso del lenguaje de programación GNU Octave. Introduce Octave como un programa multiplataforma de código abierto para cálculos numéricos, similar a MATLAB. Explica conceptos básicos como variables, operadores, matrices y vectores. También cubre funciones matemáticas predefinidas, y define funciones y cadenas de caracteres. El objetivo es familiarizar a los estudiantes con la sintaxis básica de Octave para que puedan realizar trabajos prácticos.
Este documento describe los pasos para compilar un programa Java creado en NetBeans. Primero, se verifica que Java esté instalado correctamente. Luego, se crea y guarda el programa en NetBeans y se edita el archivo Java para remover una línea de código. Después, se compila el programa usando el comando "javac" en la terminal para crear una clase, y finalmente se ejecuta usando "java".
Este documento contiene una lista de comandos y sentencias de Java. Entre los comandos se encuentran JFrame para crear ventanas, JButton para colocar botones, y SetSize() para determinar el tamaño de la ventana. También incluye sentencias como if para estructuras condicionales, y operadores lógicos como && y || para formar condiciones compuestas. El documento proporciona ejemplos de cómo utilizar estos comandos y sentencias para realizar tareas comunes en Java.
Este documento presenta un resumen de comandos y conceptos básicos de Java. Incluye instrucciones para crear ventanas, botones, establecer tamaños y títulos. También explica cómo manejar cadenas, fechas, excepciones, herencia y estructuras condicionales if-else. El objetivo es introducir conceptos de programación orientada a objetos utilizando el lenguaje Java.
Este documento describe las interfaces gráficas de usuario en Java. Introduce los conceptos de AWT y Swing, los cuales son las APIs para crear interfaces gráficas en Java. Explica las diferencias entre AWT y Swing, y describe los componentes principales utilizados para crear ventanas y añadir elementos gráficos como botones y etiquetas. También cubre los diferentes gestores de posicionamiento como FlowLayout, BorderLayout y GridLayout para organizar los componentes.
El documento presenta una introducción a MATLAB. Explica que MATLAB es un programa para realizar cálculos numéricos con vectores y matrices y que cuenta con un lenguaje de programación propio. Describe algunas de las características principales de MATLAB como su entorno de operación, los comandos más útiles y ejemplos de prácticas en clase para familiarizarse con el software.
Los documentos presentan 5 ejemplos de programas en Java y NetBeans. El primero suma números ingresados por el usuario hasta que se ingrese 25. El segundo encuentra el número del medio entre tres ingresados hasta que su suma sea 15. El tercero calcula el MCD entre tres números hasta que sea mayor a 10. El cuarto calcula áreas (cuadrado, triángulo, rectángulo y círculo). El quinto genera dos números aleatorios, compara y suma sus valores, los eleva y calcula su raíz cuadrada hasta que esta sea mayor a 4.
Este documento contiene 18 ejercicios de programación en Java con sus respectivas soluciones. Cada ejercicio realiza un cálculo o conversión diferente, como calcular el área de una esfera, convertir grados Celsius a Fahrenheit, o calcular el costo de producción de un artículo. El documento guía al usuario a través de un menú para seleccionar qué ejercicio desea ejecutar.
Conceptos básicos sobre funciones en C: que son, para qué sirven, cómo declararlas, cómo implementarlas, cómo pasar parámetros tanto por valor como por referencia, etc
El documento explica las funciones en programación. Indica que las funciones son grupos de sentencias con un nombre que realizan una tarea específica. También describe cómo se declaran, implementan y usan las funciones, incluyendo conceptos como parámetros, variables locales y tipos de retorno. Finalmente, menciona otros temas relacionados como procedimientos y el paso de parámetros por valor y referencia.
El documento describe diferentes estructuras de control de flujo en Java, incluyendo switch, while, do-while y sus usos. Explica cada estructura con ejemplos de código y diagrama de flujo. Luego presenta 16 ejemplos de aplicación que utilizan estas estructuras para resolver problemas como mostrar tablas de multiplicar, números pares/impares, factoriales y más.
El documento describe la creación de una calculadora básica en Java usando interfaz gráfica de usuario. Se importan las clases necesarias y se crea una clase Main que extiende JFrame e implementa ActionListener. El constructor crea la interfaz con botones y un cuadro de texto usando paneles y eventos de click. El método actionPerformed captura los clicks y determina la acción según el botón presionado para realizar cálculos o limpiar.
Este documento explica el concepto y uso de funciones en Java. Detalla cómo crear funciones con tipos de retorno y parámetros, cómo pasar valores y referencias a funciones, y el uso de la cláusula return. También cubre funciones recursivas que se llaman a sí mismas de forma iterativa o recursiva, como un ejemplo de factorial.
Este documento contiene información sobre subprogramas y funciones en C++. Explica las razones para crear subprogramas, como dividir la complejidad del código y promover la reutilización. También describe los pasos para escribir un subprograma, como definir el problema, darle un nombre y decidir cómo probarlo. Además, cubre temas como los parámetros, el paso de parámetros, el ámbito de variables y la recursividad. Finalmente, incluye ejercicios prácticos sobre el uso de subprogramas.
El documento presenta el código de tres métodos de ordenamiento de datos (burbuja, quicksort y shell) y explica su funcionamiento. Incluye programas que permiten al usuario ingresar datos y ordenarlos usando estos métodos. El autor concluye que aprendió a organizar y facilitar procesos complejos a través del uso de funciones en los programas.
Este documento presenta un examen de microcontroladores de 20 preguntas con opciones múltiples. El examen cubre temas como lazos, arreglos, conversión analógico-digital, comunicación serial y programación en C de PIC. Se pide a los estudiantes marcar la respuesta correcta para cada pregunta en una tabla de respuestas al final.
1) El documento describe los elementos básicos de la estructura de un programa en Java, incluyendo la entrada de datos, procesamiento y salida de resultados. 2) Explica cómo leer datos de entrada del usuario y mostrar resultados, así como diferentes formas de estructurar y documentar el código de manera clara. 3) Incluye ejemplos de programas sencillos que ilustran estos conceptos.
Similar a Gestion de la Memoria Final!!!!!.docx (20)
PRESENTACION TEMA COMPUESTO AROMATICOS YWillyBernab
Acerca de esta unidad
La estructura característica de los compuestos aromáticos lleva a una reactividad única. Abordamos la nomenclatura de los derivados del benceno, la estabilidad de los compuestos aromáticos, la sustitución electrofílica aromática y la sustitución nucleofílica aromática
1. IMPLEMENTACION EN JAVA: PARTICION FIJA EN MEMORIA
SISTEMAS OPERATIVOSPágina 8
ADMINISTRACION DE MEMORIA -PROGRAMA: ESQUEMA DE ASIGNACION DE PARTICIONES MULTIPLESº
El siguiente programa ha sido elaborado con el IDE de desarrollo para java Netbeans 6.8 , lenguaje Java.
INTERFAZ DE PROGRAMA: Control Spinner1: se hará el ingreso del
número de particiones.
Control JButton1: colocara cada proceso en
la partición que le corresponde de acuerdo al
ajuste que se haga.
2. IMPLEMENTACION EN JAVA: PARTICION FIJA EN MEMORIA
SISTEMAS OPERATIVOSPágina 9
● La función
Nparticiones, nos
retorna el número
de particiones de la memoria.
● La función Nprocesos, nos retorna el número de procesos a los cuales se les asignara memoria.
Control JButton2: permitirá el
ingreso de particiones y
procesos, de acuerdo a la
cantidad especificada.
Panel3: Mostrara la
e la Memoria con las
es respectivas, y los
a los que se ha
de acuerdo al Peor
3. IMPLEMENTACION EN JAVA: PARTICION FIJA EN MEMORIA
SISTEMAS OPERATIVOSPágina 10
● El vector v_part, guardará todos los valores de las particiones insertados en la tabla jtable2, en la columna”tamaño”
● El vector v_proc, guardará el tamaño de cada proceso insertado en la tabla jtable1, en la columna “tamaño”
FUNCION PRIMER AJUSTE:
Esta función lo primero que hará es dibujar en el panel jPanel1,la memoria con el numero de particiones que le corresponde, luego se recorrerá los vectores
v_part y v_proc, y se comenzara a comparar a cada proceso con cada una de las particiones, si se encuentra que es menor que una de éstas, entonces en la
partición correspondiente cargará éste proceso, , luego con la función InsertarProcesos y en el interfaz del programa en la posición que asigne la variable
acum se mostrará como texto por ejemplo: “proceso 1: 1000 kb”, y por último el valor de la partición en la que cargo el proceso se hará cero, así como también
el valor del proceso que cargo en la partición, todo esto se hará para tener un control de los procesos que ya se les esta asignando memoria.
FUNCION MEJOR AJUSTE:
public void PrimerAjuste(){
Vector<Integer> v_part= new Vector<Integer>() ;Vector<Integer> v_proc= new Vector<Integer>() ;
for(int i=1;i<Nparticiones();i++){
v_part.add(Integer.parseInt(String.valueOf(jTable2.getValueAt(i,1)))); }
for(int j=0;j<Nprocesos();j++){
v_proc.add(Integer.parseInt(String.valueOf(jTable1.getValueAt(j,1))));}
int v=0;
int acum_y=45;//posision y desde donde se ubicaran los procesos en las particiones
for(int j=0;j<v_part.size();j++){ v=0;
for(int i=0;i<v_proc.size();i++){
if(v==0){
if(v_proc.get(i)<v_part.get(j) && !v_proc.get(i).equals(new Integer(0))){
acum_y=67+45*(j);
InsertarProcesos ("Proceso "+(i+1)+": "+v_proc.get(i)+"Kb",acum_y,false,jPanel1);
v_part.set(j,new Integer(0));
v=1;}
else if(v_proc.get(i)==v_part.get(j) && !v_proc.get(i).equals(new Integer(0))){
acum_y=67+45*(j);
InsertarProcesos ("Proceso "+(i+1)+": "+v_proc.get(i)+"Kb",acum_y,true,jPanel1);
v_part.set(j,new Integer(0));
v=1;
}if(v==1){ v_proc.set(i,new Integer(0)); }}}}
ProcPendientes_PartVacias(v_proc,v_part,jTextField1,jPanel1 );
4. IMPLEMENTACION EN JAVA: PARTICION FIJA EN MEMORIA
SISTEMAS OPERATIVOSPágina 11
Primero se comenzara a recorrer los dos vectores: v_part y v_proc, esta función trabajara con un vector resta de tipo hashtable, en este vector se guardarán
las restas entre el tamaño del proceso y el tamaño de la partición, para ver cual resta es la mínima, éste valor se guardará en la variable min, y la posición de
ésta resta, se guarda en la variable pos, así entonces se irá obteniendo las restas de cada proceso con cada una de las particiones, y con la función
InsertarProcesos, se mostrará en el interfaz del programa qué procesos están cargados en las particiones
public void MejorAjuste(){
Vector<Integer> v_part= new Vector<Integer>() ;
Vector<Integer>v_proc= new Vector<Integer>() ;
Hashtable<Integer,Integer> resta= new Hashtable<Integer,Integer>() ;
for(int i=1;i<Nparticiones();i++){
v_part.add(Integer.parseInt(String.valueOf(jTable2.getValueAt(i,1))));}
for(int j=0;j<Nprocesos();j++){v_proc.add(Integer.parseInt(String.valueOf(jTable1.getValueAt(j,1)))); }
int pos=-1; int acum_y=45;
for(int j=0;j<v_proc.size();j++){
for(int i=0;i<v_part.size();i++){
if(!v_part.get(i).equals(new Integer(0)) && !v_proc.get(j).equals(new Integer(0))){
resta.put(i,v_part.get(i)-v_proc.get(j));} }
Enumeration<Integer> e=resta.keys();
Integer min= new Integer(100000);
while(e.hasMoreElements()){
Integer indice=e.nextElement();
if(resta.get(indice)<min && resta.get(indice)>=new Integer(0)){
min=resta.get(indice);
pos=indice; }
} if(!min.equals(new Integer(100000))){
acum_y=67+45*(pos);
if(!min.equals(new Integer(0))){
InsertarProcesos ("Proceso "+(j+1)+": "+v_proc.get(j)+"Kb",acum_y,false,jPanel2);
}
else{
InsertarProcesos ("Proceso "+(j+1)+": "+v_proc.get(j)+"Kb",acum_y,true,jPanel2);
}
v_proc.set(j,new Integer(0));}
resta.clear();//limpiamos el vestor resta
if(pos!=-1)v_part.set(pos,new Integer(0));
}ProcPendientes_PartVacias(v_proc,v_part,jTextField2,jPanel2 );}
5. IMPLEMENTACION EN JAVA: PARTICION FIJA EN MEMORIA
SISTEMAS OPERATIVOSPágina 12
FUNCION PEOR AJUSTE:
El procedimiento es el mismo que la función del Mejor ajuste, solo que aquí en vez de guardar la resta mínima, se guardara la máxima, pues el algoritmo se
trata de que cuando un proceso llega, tiene que cargar el partición mas grande que haya.
public void PeorAjuste(){
Vector<Integer> v_part= new Vector<Integer>() ;
Vector<Integer>v_proc= new Vector<Integer>() ;
Hashtable<Integer,Integer> resta= new Hashtable<Integer,Integer>() ;
Hashtable<Integer,Integer> Proc_f= new Hashtable<Integer,Integer>() ;//particion y su posicion
Hashtable<Integer,Integer> Part_f= new Hashtable<Integer,Integer>() ;// proceso y su particion
for(int i=1;i<Nparticiones();i++){
v_part.add(Integer.parseInt(String.valueOf(jTable2.getValueAt(i,1))));}
for(int j=0;j<Nprocesos();j++){
v_proc.add(Integer.parseInt(String.valueOf(jTable1.getValueAt(j,1)))); }
int pos=-1;
int acum_y=45;//posision y desde donde se ubicaran los procesos en las particiones
for(int j=0;j<v_proc.size();j++){
for(int i=0;i<v_part.size();i++){
if(!v_part.get(i).equals(new Integer(0)) && !v_proc.get(j).equals(new Integer(0))){
resta.put(i,v_part.get(i)-v_proc.get(j));
} }
Enumeration<Integer> e=resta.keys();
Integer max=new Integer(-1);
while(e.hasMoreElements()){
Integer indice=e.nextElement();
if(resta.get(indice)>=max && resta.get(indice)>=new Integer(0)){
max=resta.get(indice);
pos=índice; }
} if(!max.equals(new Integer(-1))){
acum_y=67+45*(pos);
if(!max.equals(new Integer(0))){
InsertarProcesos ("Proceso "+(j+1)+": "+v_proc.get(j)+"Kb",acum_y,false,jPanel3);
}
else{
InsertarProcesos ("Proceso "+(j+1)+": "+v_proc.get(j)+"Kb",acum_y,true,jPanel3);
}
v_proc.set(j,new Integer(0));}
resta.clear();//limpiamos el vestor resta
if(pos!=-1) v_part.set(pos,new Integer(0));}
ProcPendientes_PartVacias(v_proc,v_part,jTextField3,jPanel3 ); }
6. IMPLEMENTACION EN JAVA: PARTICION FIJA EN MEMORIA
SISTEMAS OPERATIVOSPágina 13
FUNCION INSERTA PARTICIONES: FUNCION INSERTAPROCESOS
public void InsertarParticiones(int x, int y,JPanel
jPanel){
int total;
total=0;
for(int i = 0;i<Nparticiones() ;i++){
y=y+45;
JTextField txt;
JLabel lbl;
JSeparator separador;
txt=new JTextField();
lbl=new JLabel();
separador=new JSeparator();
separador.setSize(105+10,2);
lbl.setSize(30,10);
if(i==0){//Particion del S.O
txt.setBackground(Color.lightGray);
txt.setSize(105,43-25);
separador.setLocation(x,y);
txt.setLocation(x,y+2);
txt.setText("S.O");
lbl.setLocation(x+105,y+45-25+2);
y=y-25;
}
else{
separador.setLocation(x,y);
lbl.setLocation(x+105,y+45+2);
}
jPanel.add(separador);
jPanel.add(lbl);
jPanel.add(txt);
separador.setBackground(Color.black);
total=total+Integer.parseInt(String.valueOf(jTable2.getV
alueAt(i,1)));
lbl.setText(String.valueOf(total))
}
}
public void InsertarProcesos(String proceso,int
acum_y,boolean igual_o_menor,JPanel jPanel){
int x=35;
JTextField txtp,txt;
txtp=new JTextField();
txt=new JTextField();
if (igual_o_menor==true){
txtp.setSize(105,43);}
else{
txtp.setSize(105,30);
txt.setSize(105,43-30);
txt.setLocation(x,acum_y+30);
}
txtp.setText(proceso);
txtp.setLocation(x,acum_y);
jPanel.add(txtp);
jPanel.add(txt);
txtp.setEditable(false);
txt.setEditable(false);
}
7. IMPLEMENTACION EN JAVA: PARTICION FIJA EN MEMORIA
SISTEMAS OPERATIVOSPágina 14
FUNCION PARA PROCESOS PENDIENTES:
void ProcPendientes_PartVacias(Vector<Integer> v_proc,Vector<Integer> v_part, JTextField jText,JPanel jPanel){
int suma=0,i=1;
int acum_y=45;
String texto=" ";
for (Integer p:v_proc){//for each
if(!p.equals(new Integer(0))){ texto=texto+"P"+String.valueOf(i)+" + "; suma+=p;} i+=1;
}
jText.setText(texto.substring(1,texto.length()-2)+" = "+suma+" Kb.");
i=0;
for (Integer par:v_part){//for each
if(!par.equals(new Integer(0))){ acum_y=67+45*(i);InsertarProcesos ("",acum_y,true,jPanel);}i+=1;
}
}
8. IMPLEMENTACION EN JAVA: PARTICION FIJA EN MEMORIA
SISTEMAS OPERATIVOSPágina 15
EJECUCION DEL PROGRAMA-EJEMPLO
9. IMPLEMENTACION EN JAVA: PARTICION FIJA EN MEMORIA
SISTEMAS OPERATIVOSPágina 16
ADMINISTRACIÓN DE MEMORIA-PROGRAMA :ESQUEMA DE PAGINACIÓN)
1. Descripción del Programa:
La implementación del Método de Paginación, ha sido elaborada con la Plataforma Netbeans, utilizando el lenguaje Java.
2. Descripción del Interfaz del Programa:
AREA 1
AREA 2
AREA 3
AREA 4
AREA 5
10. IMPLEMENTACION EN JAVA: PARTICION FIJA EN MEMORIA
SISTEMAS OPERATIVOSPágina 17
● Área 1: Se encuentra dentro del control JPanel (jPanel2), y dentro de ella se
hará el ingreso de los siguientes datos: tamaño del Sistema Operativo (control
jTextField1), tamaño de página(control jTextField2) y Tamaño de de Memoria
Física (control jTextField3),
● Área 2: Se encuentra también del control JPanel (jPanel2), y dentro de ella se
ingresará el número de procesos que pedirán memoria (control jSpinner1), y en
una tabla (Control jTable1), se mostrará dichos procesos con sus respectivos
tamaños, tiempo de permanencia en la CPU, y el numero de paginas que se
requiere para cada proceso.
● Área 3: Se encuentra dentro de un Panel (control jPanel2),y dentro de éste
Panel encontramos un botón (control jButton1), el cual se encargará de
procesar la información en cada instante de tiempo en el que entra y sale un
proceso de la memoria.
● Área 4: Nos muestra la Tabla de Paginas (Control jTable2) con las páginas
cargadas en memoria y los marcos en los que carga cada una de ellas, además
se muestra el proceso al cual pertenecen, está tabla de paginas variará en cada
instante de tiempo n el que entra y sale un proceso de Memoria.
● Área 5: En esta área se dibujara el Esquema de la distribución de páginas en la
Memoria Física (control jPanel1).
3. DESCRIPCIÓN DEL CÓDIGO FUENTE
a. Descripción de Vectores, variables usadas
● La variable nveces, guardara el numero de veces que se hace click en
el botón procesar (control jButton1),y así poder saber si la información
que se ingresa en la tabla jtable2 es nueva, y por ende la paginación
que se hará, será nueva.
● El vector v_marco guardará la lista de marcos disponibles en un inicio
en la memoria física sin tomar en cuenta los marcos ocupados por el
sistema operativo.
● El vector v_tiempo guarda los tiempos de permanencia de los procesos
que van entrando a la Memoria física, en cada instante de tiempo.
● El vector v_pags_proc, guarda el número de páginas que necesita cada
proceso.
● El vector de tipo integer: v_proc_pendientes, guardara los procesos
pendientes en un instante de tiempo.
11. IMPLEMENTACION EN JAVA: PARTICION FIJA EN MEMORIA
SISTEMAS OPERATIVOSPágina 18
● La función n_procesos retorna el valor que se ingrese en el control
jSpinner1, es decir el numero de procesos que pedirán memoria.
● La función Marcos_so, retorna el valor que se ingrese en el control
jTextField1, es decir la cantidad de marcos que ocupa el sistema
operativo.
● La función tamañoPag, retorna el valor que se ingrese en el control
jTextField2, es decir el numero de paginas que necesite cada proceso.
● La función TamañoMem, retorna el valor que se ingrese en el control
jTextField3, es decir el tamaño total de la memoria física.
● La función Nmarcos retorna el valor después de dividir el tamaño de la
memoria física y el tamaño de páginas, para poder hallar el número
de marcos totales.
b. Descripción de Funciones Creadas
i. Función Paginación:
Lo primero que hará esta función es comprobar si la variable nveces es
igual o diferente de cero,
Si estamos dentro del primer caso (nveces=0, inicio del proceso de
paginacion):
Se llenara el vector: v_marco, con sus respectivos índices, luego se
llenara el vector v_proc_pendientes con los valores que se encuentran
en la columna “tamaño” de la tabla jtable1, es decir el tamaño de cada
proceso que se ingresaron en un inicio. A continuación se declara la
variable tamaño_proc, que guardara el tamaño de cada proceso, para
que pueda ser dividido la variable tamaño_pag, (guarda el valor de la
función (TamañoPag), y con esto podamos obtener el numero de
páginas que necesita cada proceso, y estos últimos valores serán
guardados en el vector v_pags_proc.
Finalmente los valores del vector v_pags_proc se agregaran a la
columna “#paginas” de la tabla jtable1.
public void Paginacion_(){
PTexSale=" Sale el proceso: ";
PTexTiempo=" En el tiempo T=";
if(nveces==0){
for(Integer i=Marcos_so();i<Nmarcos();i++){
v_marco.add(i);
}
for(int i=0;i<n_procesos();i++){
12. IMPLEMENTACION EN JAVA: PARTICION FIJA EN MEMORIA
SISTEMAS OPERATIVOSPágina 19
Si estamos dentro del primer caso (nveces>0):
Se llama a la función EliminaOcupados, luego pasamos a hallar el
tiempo mínimo que se encuentra en el vector v_tiempo, esto se hace
para ver cada qué tiempo tendremos que detenernos y ver si algún
proceso libera memoria y si otro proceso pendiente puede entrar a
cargar en ese espacio libre, el tiempo mínimo hallado lo guardamos en
la variable min, este valor tendrá que restarse a cada valor del vector
v_tiempo que sea mayor a cero, y así poder llevar un control de los
tiempos de permanencia de cada proceso en cada instante de tiempo.
En una tabla temporal (jTable3), se copiara la información de los
procesos que aún están ocupando marcos en la memoria física de la
tabla jtable2,al momento de copiar los datos de una tabla a otra, se
tiene que tener en cuenta el índice desde donde se copiaran los
elementos, este índice se guardara en la variable pos_tabla_temp, todo
esto se hace para mantener la información actual de los marcos libres y
ocupados en cada instante de tiempo; luego de esto, se podrá limpiar
la tabla de paginas jtable2, para que pueda mostrar la información en
un nuevo instante de tiempo, así como también inicializar la posición
de ésta tabla nuevamente en cero, con la variable pos_tabla_pag.
Por otro lado, lo que hace ésta función es verificar desde un inicio, si el
número de páginas de cada proceso que están en el vector
v_pags_proc, son menores que los marcos disponibles (vector v_marco
) en memoria y alcanzan totalmente en ella, si es que es así,
inmediatamente esas paginas pasan a copiarse en orden en aquellos
marcos, y para tener control de los números de marcos que ya están
ocupados en un instante de tiempo, se harán cero todos aquellos
marcos ocupados en el vector v_marco, lo mismo se hace para tener el
13. IMPLEMENTACION EN JAVA: PARTICION FIJA EN MEMORIA
SISTEMAS OPERATIVOSPágina 20
control de los procesos a los cuales ya se les asigno memoria, también
se harán cero los valores de aquellos procesos en el vector
v_proc_pendientes.
A los valores anteriormente mencionados se les asigna el valor de cero,
para que en otro instante de tiempo, (en el caso de los procesos), poder
comparar el número de paginas solo de los procesos que están en
espera de memoria, es decir los que no son cero.
Y en el caso de los marcos, el valor cero sirve para que se lleve una
cuenta de los marcos libres en la función MarcosDisponibles,y así ver si
algún proceso pendiente puede pasar a cargar en dichos marcos.
El uso de las tabla temporal (jtable3) que esta como no visible, servirá
de ayuda a la tabla de paginas (jtable2), como se dijo anteriormente, es
para llevar un control de los procesos que aun no liberan memoria, así
como también los marcos que ya se están liberando, estos marcos
liberados lo único que harán es apilarse al vector v_marco, en el índice
que les toca.
La otra parte del código muestra en el botón procesar (button1), el
tiempo en que sale y entra y uno o mas procesos, para esto se ha
utilizado las variables globales de tipo string PtextEntra, que
guarda:”Entra el Proceso:”, la variable PtexSale: “Sale el Proceso:”,
PtexTiempo: “En el Tiempo T=”, y finalmente también se ha utilizado la
variable global de tipo integer TiempoAcumulado, que guardará el
tiempo actual en el que nos encontramos; todos estos valores se
concatenaran y mostraran en botón procesar.
if(nveces>0){
v_marco=EliminarOcupados(v_marco);
Enumeration<Integer> e=v_tiempo.keys();
Integer min= new Integer(100000);
while(e.hasMoreElements()){
Integer indice=e.nextElement();
if(v_tiempo.get(indice)<min && v_tiempo.get(indice)>cero){
min=v_tiempo.get(indice) }
Hashtable<Integer,Integer> tiempos_temporales= new
Hashtable<Integer,Integer> ();
Enumeration<Integer> temp=v_tiempo.keys();
while(temp.hasMoreElements()){
Integer i=temp.nextElement();
if(v_tiempo.get(i).equals(min)){
tiempos_temporales.put(i, v_tiempo.get(i));
PTexSale=PTexSale+(i)+", "; }
tiempos_temporales.clear();
for(int i=0;i<jTable2.getRowCount();i++){
jTable2.setValueAt(" ", i,0);
jTable2.setValueAt(" ", i,1);
jTable2.setValueAt(" ", i,2); }
pos_tabla_pag=0;
for(int j=0;j<Nmarcos()-Marcos_so()-v_marco.size();j++){
TablaPagina(j,Integer.parseInt(String.valueOf(jTable3.getValueAt(j,0))),Inte
ger.parseInt(String.valueOf(jTable3.getValueAt(j,1))),String.valueOf(jTable3
.getValueAt(j,2)),jTable2);
pos_tabla_pag=j+1 }
jTable3.removeRowSelectionInterval(0,39);}
PTexEntra = " Entra el proceso: ";
for (int i = 0; i < v_Pags_proc.size(); i++) {
if (!v_Proc_pendientes.get(i).equals(cero)) {
if (v_Pags_proc.get(i).intValue() <=
14. IMPLEMENTACION EN JAVA: PARTICION FIJA EN MEMORIA
SISTEMAS OPERATIVOSPágina 21
ii. Función EliminarOcupados:
Esta función es de tipo vector, y lo que hace es recorrer el vector
v_marco, y ver que números de marcos están ocupados (los que son
cero) a estos últimos los elimina y una vez que los elimina, retorna el
vector, pero solo con los numero de marcos que están libres(los que no
son cero).
iii. Función MarcosDisponibles:
Es una función de tipo integer, y lo que hace es contar cuantos marcos
están disponibles, para si en caso exista algún proceso pendiente con
public Vector<Integer> EliminarOcupados(Vector<Integer>v_marco){
for(int i=0;i<v_marco.size();i++){
if(v_marco.get(i).equals(cero)){
v_marco.remove(i);
i--;
}
}
return v_marco;
}
15. IMPLEMENTACION EN JAVA: PARTICION FIJA EN MEMORIA
SISTEMAS OPERATIVOSPágina 22
menos o igual numero de paginas que los marcos disponibles los pueda
ocupar, para esto se utiliza una variable cont, que se inicializa en cero,
y aumenta a la medida en que se encuentra un marco diferente de cero
en el vector v_marco, luego la función nos retorna la variable cont.
iv. Función TablaPágina
Esta función no nos retorna ningún valor, lo único que hace es copiar
los elementos de una tabla a otra, por eso tendrá como parámetros, la
posición de la fila desde donde copiara los valores (i), el nombre de
columnas de la tabla, y la tabla a donde se copiara la información. Por
ejemplo, llenar la tabla de paginas (jtable2) con los datos de la tabla
temporal, con sus valores correspondientes a cada fila y columna.
v. Función InsertarMarcos
Lo que hace esta función es insertar como texto el nombre de cada
marco en el área donde se dibuja la memoria física en el interfaz del
programa y al mismo tiempo dividir la memoria con el número de
marcos que ésta tendrá de acuerdo a los datos ingresados en el área 1
del interfaz del programa, pues se tendrá en cuenta el número de
marcos asignados al sistema operativo.
public Integer MarcosDisponibles(Vector<Integer> marco){
Integer cont =cero;
for(Integer o:marco){
if(!o.equals(cero))cont+=uno;
}
return cont;
}
public void TablaPagina(int i,Integer pagina,Integer
marco,String proceso,JTable jTable){
jTable.setValueAt(pagina, i, 0);
jTable.setValueAt(marco, i,1);
jTable.setValueAt(proceso, i,2);
}
public void InsertarMarcos(int x, int y,JPanel jPanel){
for(int i=Marcos_so();i<=Nmarcos()+1;i++){
y=y+20;
JTextField txt=new JTextField();
JLabel marco=new JLabel();
JSeparator separador=new JSeparator();
separador.setSize(100,2);
marco.setSize(45,10);
txt.setBackground(Color.yellow);
16. IMPLEMENTACION EN JAVA: PARTICION FIJA EN MEMORIA
SISTEMAS OPERATIVOSPágina 23
vi. Función InsertandoMarcosNulos
Comenzara a dibujar la memoria física con la cantidad de marcos
totales, sin considerar los que ocupa el sistema operativo
vii. Función ObteniendoPaginasTabla
Esta función lo primero que hará es recorrer la tabla de paginas
(jtable2), y con estos valores, presentar la distribución de paginas de los
void InsertandoMarcosNulos(){
for (Integer marco:v_marco){
Dibujando("",marco-4,jPanel1);
}
}
17. IMPLEMENTACION EN JAVA: PARTICION FIJA EN MEMORIA
SISTEMAS OPERATIVOSPágina 24
procesos cargados en los marcos de la memoria física que se dibuja en
el panel (jPanel1) del interfaz del programa, esto se hará con la ayuda
de la función Dibujando, que esta a continuación.
viii. Función Dibujando
Esta función se encargará de presentar en el panel jpanel1, la
distribución de páginas que cargarán en los marcos pero en cada
instante de tiempo, es decir solo nos muestra el esquema de
distribución para poder visualizar como va quedando la memoria tras
cargar una pagina en un marco o tras la
liberación de memoria.
4. CONTENIDO DE CONTROLES
a. Botón “Ingresar “Control jButto2:
public void ObteniendoPaginasTabla(){
for(int
i=0;i<jTable2.getRowCount();i++){
if(!jTable2.getValueAt(i,2).toString().eq
uals(" ")){
Dibujando("
Pág#"+jTable2.getValueAt(i,0)+"
"+jTable2.getValueAt(i,2),Integer.parseIn
t(String.valueOf(jTable2.getValueAt(i,1))
)-Marcos_so(),jPanel1);
}
else {break;}
}
}
public void Dibujando(String pagina,int
indice,JPanel jPanel){
indice=44+20*indice;
int x=60;
JTextField txt;
txt=new JTextField();
txt.setSize(100,18);
txt.setLocation(x,indice+20);
txt.setText(pagina);
txt.setFont(new java.awt.Font("Arial", 1,9));
jPanel.add(txt);
txt.setEditable(false);
}
public void clear(){
if (jPanel1 !=null ){
Graphics gr =jPanel1.getGraphics();
repaint();
}
}
private void
jButton2ActionPerformed(java.awt.event.ActionEvent evt) {
for(int
i=0;i<Integer.parseInt(String.valueOf(jSpinner1.getValue(
)));i++){
18. IMPLEMENTACION EN JAVA: PARTICION FIJA EN MEMORIA
SISTEMAS OPERATIVOSPágina 25
b. Botón “Procesar“ Control jButton1:
private void
jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
jPanel1.removeAll();
clear();
Paginacion_();
if(nveces==0){
jButton1.setText(PTexTiempo+"0"+PTexEntra);
}
else
jButton1.setText(PTexTiempo+PTexEntra+PTexSale);
nveces+=1;
InsertarMarcos(60,0,jPanel1);
ObteniendoPaginasTabla();
InsertandoMarcosNulos();
}
19. IMPLEMENTACION EN JAVA: PARTICION FIJA EN MEMORIA
SISTEMAS OPERATIVOSPágina 26
5. EJECUCIÓN DEL PROGRAMA-EN EL INSTANTE 0