Infinitos procesos

Para que sea una entrada infinita tienes que usar listas enlazadas (punteros, una estructura nodo, debes conocerla si ya te enseñaron punteros, sino, puedes preguntarme)
Necesitaría más detalle de tu problema, para entrar en más detalle para tu respuesta.
Haber digamos que los procesadores resuelven el problema de 1 a 30 pasos, pero estos pasos ahora los entiendo como una variable aleatoria también.
Bueno entonces tendrías que crear una lista enlazada, en uno de sus campos del nodo tendrías el nombre del proceso, también el numero de proceso, y el numero de pasos en los que se terminó de atender. Luego tendrías el contador de pasos, y cuando pases de los 1000 pues recorrer esa lista enlazada.
Si aun no sabes de que trata listas enlasadas y punteros puedes confírmamelo y te podría pasar un código para que veas el funcionamiento de una lista, en la cual ingresas por decir, los nombres de personas, y su sexo, y cuando se cumplan digamos 20 ingresos, te suelta el numero de hombres y mujeres que hay, y cosas así.
¿Ok?, pásame la voz para preparar ese código, y si ya sabes de que trata una lista y también lo de punteros, entonces creo que no tendrías mucho problema con este asunto, y si los tienes pues, aquí estaré para ayudarte. Hasta entonces

Me puedes pasar ese código del que me hablas por favor, ah y si cada proceso tiene una identificación numérica que se genera consecuitivamente a partir de 1
Cada proceso se ejecutara entre 1 y 30 pasos de tiempo(fijados aleatoriamente al llegar el proceso)

Bueno veras, el código que te paso aquí, trabaja con listas enlazadas.
La función de este código es recoger un dato entero que tu ingresas, y cuando tu deseas muestras los datos que ya has ingresado hasta el momento.
Cuando lo pruebes te darás cuenta de que trata mejor.
Si es que aun no tienes concreta idea de como hacer tu programa solo me dice y le ayudaré con lo que falta.
Aquí esta el código
////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include <iostream.h>
#include <stdlib.h>
#include <conio.h>
struct nodo{
int info;
nodo *sgt;
};
void agrega(nodo **cab, nodo **fin);
void muestra(nodo *cab);
int main()
{ nodo *c=NULL,*f=NULL;
  int opcion;
   do{
   system("cls");
   cout<<"1) Ingresa un dato (numero entero)."<<endl;
   cout<<"2) Muestra los datos ingresados."<<endl;
  cout<<"ingrese opcion"<<endl;
  cin>>opcion;
  switch(opcion){
  case 0: exit(0);break;
  case 1: agrega(&c, &f);break;
  case 2: muestra(c);break;
  }
  }
  while(opcion!=0);
      system("PAUSE");
      return 0;
}
/////////funcion que recibe los datos que uno ingresa, recordar que son numeros enteros
void agrega(nodo **cab, nodo **fin){
int num;
cout<<"ingrese informacion"<<endl;
cin>>num;
if((*cab)==NULL){
*cab = new nodo;
(*cab)->info =num;
(*cab)->sgt=NULL;
(*fin)=(*cab);
}else{
(*fin)->sgt=new nodo;
(*fin)->sgt->info=num;
(*fin)=(*fin)->sgt;
(*fin)->sgt=NULL;
}
}
///// funcion que muestra los datos
void muestra(nodo *cab){
cout<<"elementos en la lista"<<endl;
nodo* temp;
temp=cab;
while ( temp != NULL){
cout<<temp->info<<"   ";
temp=temp->sgt;
}
getche();
}
Hasta pronto, y siga trabajando ;)

La verdad no tengo mucha idea porque los procesos que van a entrar se deben generar consecutivamente tienen una identificación numérica a partir de 1(¿significa eso que es manual? ¿O es algo aleatorio?) Al momento de llegar los procesos a uno de los 4 procesadores(¿quiénes vendrían hacer esos procesadores? Cada procesador ejecuta un proceso durante una cuota máxima de 10 pasos de tiempo, los procesadores funcionan sincronizados simultáneos e independientes) que hay se debe ejecutar entre 1 y 30 pasos de tiempo fijados aleatoriamente

La verdad no entiendo bien el problema. Que te parece si me lo escribes tal como es, y ahí yo ya podría especular con mejor precisión. Por que ahora solo tengo ideas borrosas de tu problema. No entiendo bien la parte en que dices :
Cada procesador ejecuta un proceso durante una cuota máxima de 10 pasos de tiempo,
y luego dices : que hay se debe ejecutar entre 1 y 30 pasos de tiempo fijados aleatoriamente.
Yo entiendo más o menos lo que quieres decir por que si he tenido este problema.
La estadística que te pide como salida creo que es, cada proceso: se muestre su identificación, el computador que lo procesó, y el tiempo que demoró.
Si hacemos un esquema sería que tienes 4 procesadores desocupados en un principio.
Viene un proceso, el cual empieza con su identificación en 1, luego consecutivamente va aumentando.
Los pasos de tiempo se pueden medir como si fueran valores de unidad que van en aumento en un contador.
Es decir, el primer espacio de tiempo pasa cuando cont = 1, el segundo, al ser cont = 2
y así y así, como si fueran segundos.
Bueno. El proceso aparece. Entonces tiene que buscar que computador va a ser el que lo procese, obviamente tiene que ser un computador libre, y si no hay uno libre entonces tiene que esperar hasta que uno de ellos se desocupe, y entonces elegirlo para que sea quien lo procese. En ese momento habrá un tiempo que aparecerá de modo aleatorio, ese tiempo tiene un rango de valores que puede tomar, el cual supongo es de 1 a 10 por que tu mencionaste: cada procesador ejecuta un proceso durante una cuota máxima de 10 pasos de tiempo
entonces mientras pasa el tiempo, otros ordenadores ya se van desocupando, y otros procesos van apareciendo, supongo que no necesariamente los procesos aparecerán uno tras otro, posiblemente, aparece el primero, el siguiente proceso aparecerá en 3 pasos de tiempo, el 3er proceso aparecerá el siguiente paso de tiempo, y el 4 proceso en el décimo paso de tiempo. Para que vayan apareciendo aleatoriamente los procesos también debe estar regido por una variable aleatoria.
Lo que debe terminar mostrando tu programa, supongo, es algo así
PROCESO Nº 1
Procesador: 3
Tiempo de procesado: 9
-------------------------------
PROCESO Nº 2
Procesador: 1
Tiempo de procesado: 3
-------------------------------
PROCESO Nº 3
Procesador: 2
Tiempo de procesado: 6
Y así y así hasta que terminen de cumplirse los 1000 pasos que es el máximo mencionado en tu problema.
Eso es lo que entiendo. Mejor me lo aclaras mostrándome tu problema, y también quiero que me aclares por que dices:
Cada procesador ejecuta un proceso durante una cuota máxima de 10 pasos de tiempo,
y luego dices
ejecutar entre 1 y 30 pasos de tiempo fijados aleatoriamente
que indica cada una de esas oraciones exactamente.
Bueno entonces espero tu respuesta. Hasta la próxima.

¿Me puedes dar tu correo? Y te lo paso

[email protected]
No entro ahí muy seguido pero igual agrégame y estaré en contacto lo antes posible

Ok ya te lo envíe

Tengo una duda sobre el funcionamiento de los procesadores
veras, dice que un procesador ejecuta un proceso durante 10 pasos
luego, ¿si es que viene un proceso de 20 pasos?
Que va a pasar con ese proceso
Por que se supone que ahí pasan 10 pasos, y luego el procesador según dice deja de ejecutar ese proceso.
Entonces que pasa con el proceso, ¿se elimina? No creo, tengo una idea de lo que puede pasar pero supongo que está errada, ¿mejor dime como hace para tener una idea mejor ok? Por que esa parte es importante. Hasta entonces

Según lo que yo entendí el tiene que volver a la estructura para que cuando le toque otra vez pasar por el procesador se ejecute, pero no se elimina

Ok entonces con esa duda resuelta podremos trabajarlo, yo te aviso por que ahorita es muy tarde, son la 1 am, tengo que descansar.

Según me explicaron los procesos deben entrar automáticamente, y que como hay 4 procesadores cada uno tiene digamos que su propia cola entonces por eso cada proceso vuelve a su cola si necesita de más pasos para culminar

Yo entiendi que si un proceso aun no se termina después de los 10 pasos de ejecución, busca a otro procesador que esté descocupado o que tenga menos pasos para desocuparse.
Por que según tu me dices, si el proceso 1 no termina en esa cola, digamos del procesador 1, se regresa pero al finaaaaaaaaal de la cola misma, ¿eso es así? Por que si es así mi algoritmo tengo que cambiarlo.
Te repito que según lo que yo hago, es lo siguiente.
Si un procesador termina sus 10 pasos de ejecución y el proceso aun no termina, entonces busca el procesador que más le convenga. ¿Esta bien así? ¿O lo cambio?
A por cierto, yo te voy a decir el algoritmo, con funciones y lo demás, los códigos te corresponderá a ti por que no se en que lenguaje estarás trabajando.
Pero con las funciones que te voy a explicar es suficiente, tu la haces para codificar, fácil está. ¿Ok?
Aclarame por fa eso de los procesos que se desocupan.

Los procesos deben de volver a la cola donde se metieron por primera vez porque si no no se cumplirá que los procesos no pueden migrar a otroa procesadores por ejemplo un proceso entra en el procesador 1 y si aun le falta pasos de tiempo de volver a la misma cola donde se metió por primera vez no megrar a otras

Esta un poco complicado explicar lo que he pensado, pero haré el intento, espero quede claro.
Las estructuras que vamos a usar son:
PROCESADOR {
entero : pasos_desocuparse
Entero: proceso_ejecutando // aquí ponemos el numero de proceso que se está ejecutando
entero: pasos_terminar_proceso //aquí ponemos el numero de pasos en que se va a // terminar de ejecutar un proceso.
apuntador procesador: sgtep
apuntador COLAPROCESO: sgtec
}
PROCESO {
entero: N_proceso
entero: prioridad
entero: pasos
Booleano: culminado // indica si o no ha sido terminado el proceso
booleano: asignado // indica si está asignado a alguna cola
entero: procesador_termina // indica el numero de procesador que lo terminó
apuntador proceso: siguiente
}
COLAPROCESO {
entero: N_proceso
apuntador COLAPROCESO: sgt
}
Bien, la idea hasta aquí es que tu tienes 4 procesos enlasados con el apuntador sgtep, y se enlazan a su cola con el apuntador sgtec
luego puedes recorrer la cola usando el apuntador sgt.
Y la estructura proceso pertenecerá a una lista de procesos, que se irá haciendo más grande según se vayan creando los procesos.
Esa lista estará enlazando a los procesos con el apuntador sgt.
Bien ahora voy a plantear la función que va a crear a los procesos de forma aleatoria, para luego asignarlos a la lista de procesos, y luego haré la función que va a asignar a los procesos de la lista, que no estén asignados a una cola, a una de las 4 colas de los procesadores.
FUNCION creaprocesos(){
Entero: creados
creados = rand(1,10) // haces que la variable tome un valor aleatorio de 1 a 10
según sea (creados) entonces{
Caso de 1 :
Caso de 2 :
Caso de 3 :
caso de 4 : creados =1
Caso de 5 :
Caso de 6 :
Caso de 7 :
caso de 8 : creados =2
caso de 9 : creados = 3
caso de 10: creados = 0
// con esto seguimos la condicion de porcentajes para la creacion aleatoria
}
para i = 1 hasta creados
// hacemos un rand para prioridad y para los pasos
// Tomando en cuenta que en tu programa, tengas una variable global de puntero a //PROCESO que apunta al ultimo proceso de la lista que se llama ultimo
// entonces agregamos los procesos uno a uno, ademas proc es el puntero
// cabecera de la lista será
si(ultimo = null) entonces // si aun no hay elementos en la lista de procesos
proc = nuevo PROCESADOR
ultimo = proc
sino
ultimo.sgt = nuevo PROCESADOR
ultimo = ultimo.sgt
fin_si
ultimo.prioridad = rand(1,3)
ultimo.pasos = (1,30)
ultimo.culminado = NO
ultimo.asignado=NO
ultimo.N_proceso = contador // este contador será una variable global que  ira                                          //aumentando segun vayan creandose los procesadores
contador = contador + 1
fin para
}
La función de asignar procesos es la siguiente
Función asignaprocesos
ahora recorremos la lista de procesos con un puntero
y vamos a buscar a los que esten sin asignacion, respetando sus prioridades
puntero PROCESO : temp
temp = proc // no olvidar: proc es global y seimpre apunta al inicio de la lista de procesos
mientras temp != null hacer
para priori = 3 hasta 1
si ( priori=temp.prioridad y temp.asignado =no){
Aqui haste un codigo para que recorra a los 4 procesadores y busque al que tenga menos pasos a desocuparse (variable pasos_desocuparse)
Y cuando lo encuentre lo añades al final de la cola que está ligada a ese procesador
}
fin para // priori baja de 3 a 1 asi se completa la asignacion de todas las prioridades
temp = temp.sgte
fin mientras
fin_funcion
Hasta aquí ya tienes tus funciones que asignan y crean, ahora aquí está la parte del algoritmo que va a recorrer los 1000 pasos y va a hacer el funcionamiento de los procesadores, asignaciones, términos, etc. Luego tu haces los algoritmos que boten las estadísticas. Eso ya está fácil por que solo tienes que recorrer las listas de forma estratégica.
CODIGO QUE AÑADIRAS A TU ALGORITMO
para i = 1 hasta 1000
creaprocesos()
asignaprocesos()
puntero PROCESADOR : temp // con esto recorremos los 4 procesadores
temp = cab // cab será tu variable global que apunta al primer procesador
mientras(temp != null){
si(temp.pasos_terminar_proceso = 0){
|
|   temp.proceso_ejecutando=temp.sgtec.N_proceso
|   temp.sgtec = temp.sgtec.sgt
|
|   //hasta ahora lo que se ha hecho es verificar si el procesador ha terminado de |//ejecutar
|//el ultimo proceso que ejecutaba, entonces coje al siguiente de la cola, asignandose
|//el N_ proceso que es el numero del proceso, y saltando su apuntador de la cola
|//al siguiente de la cola   temp.sgtec = temp.sgtec.sgt
|
|//como tienes el numero de proceso que se debe ejecutar entonces tienes que ubicarlo |// para hacer el siguiente codigo
|
|    //sea puntero un puntero a PROCESO
|       puntero = proc  // proc es cabeza de la lista
|     
|        mientras (puntero.N_proceso != temp.proceso_ejecutando)
|          puntero = puntero.sgte
|       fin mientras   // en este para se saltea el puntero de proceso a proceso en la lista
|                      // hasta llegar con el puntero que posee el mismo numeero que el valor
|                      // que esta asignado en temp.proceso_ejecutando
|
|   si ( puntero.pasos <=10){
|          temp.pasos_terminar_proceso = puntero.pasos
|        }sino{
|      
|          temp.pasos_terminar_proceso = 10
|        }fin_si
|
| fin_si
temp.pasos_desocuparse = temp.pasos_desocuparse-1
temp.pasos_termina_proceso = temp.pasos_termina_proceso - 1
puntero.pasos = puntero.pasos -1
// en el proceso, en este paso del 1 al 1000, se ejecuta un paso en el proceso y en el
// ordenador, por eso bajamos uno a cada una de esas variables.
si(temp.pasos_termina_proceso=0  y  puntero.pasos>0){  // esto significa que si
  // se termina la ejecucion de pasos del proceso en el procesador y el numero
// de pasos del proceso aun es mayor que cero, este proceso debe pasar al final
// de la cola.
//aqui has un algoritmo que recorra la cola del procesador apuntado con temp
//hasta llegar al ultimo de la cola, para asi asignarle el nuevo elemento
//que es el que se esta dejando de ejecutar
// si se hace y el puntero que apunta al final se llama ultimo, el algoritmo sigue asi
ultimo.sgt = nuevo COLAPROCESO
ultimo=ultimo.sgt
ultimo.N_proceso = temp.proceso_ejecutando
}
//segumos usando puntero como el puntero que apunta al proceso de la cola.
si (puntero.pasos=0) // se termino de ejecutar el proceso y se culminó
puntero.culminado = SI
puntero.procesador_termina = temp.N_procesador
fin_si
temp = temp.sgtep
}fin mientras // se repite hasta que temp = null
fin para  // esto se repite 1000 veces
Es una larga respuesta pero con esto tu programa esta terminado prácticamente
ahora solo pon de tu parte codificando en el lenguaje que usas.
HASTA OTRA OPORTUNIDAD ;) no olvides puntuar, ya que me ha llevado tiempo. XD