General

Buenas.

En el curso se han visto algunas instancias de uso de arreglos para resolver problemas, pero quería verificar si estaba permitido su uso en cualquier momento
La pregunta viene motivada por el hecho que durante el último práctico calificado tenía la solución correcta pero sencillamente no me dio el tiempo para poder plasmar la solución en el papel, pues había muchas instancias de objetos para especificar pero que básicamente tenían un comportamiento análogo. El docente sugirió hacer uso de arreglos para estos casos.
Dejo entonces ejemplos para cada uno de las herramientas de concurrencia vistas en el curso.

Semáforos: ¿es válido definir un arreglo de semáforos, o cualquier otra variable?
Ejemplo:

===
program ejemplo
semaforos: array [1..n] of semaphore
otras_vars: array [1..n] of int
...
def main():
begin
    ...
    for i in 1..n:
        init(semaforos[i], i) // en este caso cada entrada se inicializa con un valor incremental, igualmente podría usarse una constante cualquiera
        otras_vars[i] = i // idem
    end
    ...
    cobegin
        ...
    coend
end
===

Monitores: ¿es válido definir un arreglo de condition, o variables cualquiera? ¿Se puede pasar un argumento para a un método del monitor para seleccionar uno?
Ejemplo:

===
program ejemplo
monitor Monitor
    condicion: array [1..n] of condition
    otras_vars: array [1..n] of int
    ...
    def init():
    begin
        ...
        for i in 1..n
            otras_vars[i] = i
        end
    end

    def usar(int: i):
    begin
        ...
        condition[i].wait()
        ...
        condition[i].signal()
        ...
    end
end
...
def main():
begin
    ...
    cobegin
        ...
    coend
end
===

Mailbox: en este caso entiendo que se pueden usar arreglos porque lo hemos visto, pero por completitud dejo un ejemplo.

===
program ejemplo
boxes: array[1..n] of mailbox(int, int)
...
def main():
begin
    ...
    for i in 1..n
        send(boxes[i], (i,i))
    end
    cobegin
        ...
    coend
end
===

Ada: finalmente está el caso de Ada. Aquí por lo que me comentó un docente en un práctico se puede incluso usar arrays para los entrypoints, aunque no me quedan claros los detalles de la sintaxis.

===
program ejemplo
task tarea is
    array [1..n] of entry entrada(a: IN int, b: OUT int) // no sé si esta es la sintaxis preferida o da igual
end
task tarea body is
var
    vars: array [1..n] of int
    ...
begin
    ...
    accept entrada[i](a: IN array [1..n] of int, b: OUT array [1..n] of int) do // aqui tengo acceso a i, a y b?
        ...
    end
end

task type invocador is
end
task type invocador body is
var
    a: array [1..n] of int
    b: array [1..n] of int
begin
    ...
    select
        ejemplo.entrada[i](a, b) // tampoco me queda claro cómo es
    end
    ...
end

def main():
begin
end
===

Acepto cualquier otro comentario al respecto de los ejemplos que puse.
Saludos.