ripartire correttamente nodi tra router

[omniaforever]

Ragazzi avrei bisogno di una semplice soluzione algoritmica.
Vi presento il mio problema.
Praticamente in ingresso setto 2 variabili che sono
Nrouter (numero di router)
Nnode (numero di nodi per router)

tuttavia i nomi dei nodi sono non distinti anche se appartengono a 2 classi differenti(cioè o sono nodi semplici o sono nodi router, ma nella realtà saranno nominati tutti allo stesso modo come un vettore di n nodi)

Faccio un esempio:
supponiamo che Nrouter è 2 e Nnode è 2, avrò quindi 2 nodi per ognuno dei 2 router + i 2 router, quindi avrò in generale n(0),n(1),n(2),n(3),n(4),n(5)

manualmente potrei partizionare cosi':
n(0) il primo router
n(1) e n(2) i 2 nodi del primo router
n(3) il secondo router
n(4) n(5) i 2 nodi del secondo router

oppure mettere n(0) n(1) i 2 router e n(2) n(3) i 2 nodi del primo router e n(4) n(5) i 2 nodi del secondo router

in pratica nei 6 nodi ho bisogno di settare i 2 router,e per ogni router i 2 nodi (dato che ogni router riceverà pacchetti solo dai nodi relativi)

non so se mi sono spiegato.
qual è una semplice soluzione algoritmica che dato un numero di router e di nodi per router, e sapendo che tutti i nodi sono indistintamente (sia router che nodi) in un vettore n(0)...n(i)...., che permetta di assegnare i router ed assegnare i nodi ai vari router?vorrei evitare liste e simili, se si potesse lavorare con operazioni modulo sarebbe preferibile, anche perchè devo fare ciò in uno script tcl per ns2(simulatore di reti)
in pratica ogni router si deve settare in ricezione ,ed ogni nodo non router deve trasmettere solo al router associato attraverso un proprio canale
devo fare una cosa del tipo:
ciclo i vari nodi della rete
a seconda dell'indice posso assegnarlo come router oppure come semplice nodo connesso ad un router
#se il nodo è router
n(i) setto in ricezione
#se il nodo è nodo semplice
n(j) trasmetto al router n(i) associato (preferibilmente capire qual è l'indice i del router con operazioni come divisione e modulo)

[lupoxxx87]

ma...

la rete che struttura ha ?
perchè un nodo semplice può essere collegato solo a un router. e di conseguenza ogni router crea una propria sottorete, per cui gli indirizzi vengono ripartiti, e poi ci sono le reti di collegamento tra router.

non credo ci sia una soluzione standard indipendente dalla struttura della rete

[omniaforever]

ma...

la rete che struttura ha ?
perchè un nodo semplice può essere collegato solo a un router. e di conseguenza ogni router crea una propria sottorete, per cui gli indirizzi vengono ripartiti, e poi ci sono le reti di collegamento tra router.

non credo ci sia una soluzione standard indipendente dalla struttura della rete

non la vedere sotto questo punto di vista + complesso.te li ho chiamati router e nodi per semplicità, ma potevo chiamari anche patate e fagioli.
mi interessa soltanto dato un numero di nodi per router ed un numero di router, e dato una serie di nodi che sono i nodi non router e router, come ripartirli (come l'esempio che ho fatto, ma come raggiungo quella situazione per via algoritmica)?cioè la suddivisione router e nodi me la faccio dopo, dato che dopo decido chi trasmette e chi riceve.non ti preoccupare di strutture di reti,indirizzi, etc,non me ne frega nulla.. mi interessa solo partizionarli come nell'esempio che ripropongo

cioè riprendendo l'esempio, se ho 2 router e 2 nodi per router otterrò una sequenza da n(0) a n(5) (6 nodi, dato che sono 2 nodi x 2 router + 2 router).
cioè dati in ingresso Nnode 2 e Nrouter 2, mi creo Nnode*Nrouter+Nrouter nodi, quindi 6 nodi tutti uguali al momento senza distinzione di funzioni tra di essi, ma solo adesso devo essere io a partizionarmeli realmente nei router e nei nodi associati(a cui associerò le funzioni corrispondenti)
voglio ad esempio che
n(0) il primo router
n(1) e n(2) i 2 nodi del primo router
n(3) il secondo router
n(4) n(5) i 2 nodi del secondo router

oppure mettere n(0) n(1) i 2 router e n(2) n(3) i 2 nodi del primo router e n(4) n(5) i 2 nodi del secondo router


come ottengo ciò che via algoritmica?
cioè sapendo che la sequenza n(0) to n(5) (che non si sa ancora se sono nodi semplici o router)deriva da 2 router e 2 nodi per router, come faccio a partizionare in uno dei 2 esempi mostrati prima?

immagino una cosa del tipo (seguendo ad esempio l'ultima idea di partizione proposta)
for (i=0 i<numero router i++)
{
n(i) è un router
}
for (i = numero router ; i < numero router*nodi per router + numero router;i++)
{
n(i) è un nodo semplice associato al router X
}

quello che principalmente mi sfugge è trovare il router X, cioè come associare correttamente 2 nodi al router n(0) e gli altri 2 al router n(1)..qualche operazione in modulo o non so..

oppure un algoritmo analogo in cui i primi 3 nodi da n(0) ad n(2) sono il router e i 2 nodi associati, e cosi' per n(3) to (5), come la prima idea di partizionamento
spero che sia stato un po' più chiaro

[lupoxxx87]

cioè tu vuoi solo metterli in un array ?
allora puoi fare

for (i=0; i<nrouter*(nnodi+1);) {
array(i)=router; // i-esimo router
for(j=1; j<=nnodi; j++)
array(i+j)=nodo; // j-1 esimo nodo dell'i-esimo router
i=j;
}

[cionci]

Sinceramente non ho capito bene le regole sulle quali fare questa partizione. Quale ordine hanno nel vettore ?

[omniaforever]

Sinceramente non ho capito bene le regole sulle quali fare questa partizione. Quale ordine hanno nel vettore ?

come supponevo mi sono spiegato da cani hihi

allora ripartiamo:
il mio script in ingresso ha:
Nnode (numero di nodi per router)
Nrouter (numero router)
sulla base di questi ingressi il mio script genera un vettore di nodi(senza distinzione tra router e nodi semplici) in base a
Nnode*Nrouter + Nrouter, in pratica nel caso di Nnode = 2 e Nrouter = 2 genera 6 nodi, da n(0) a n(5), che rappresenteranno appunto i 2 router, e 2 nodi per ognuno dei 2 router,ma al momento rappresentano soltanto 6 nodi uguali.
Questi n(0)..n(5) sono al momento solo creati, sono tutti nodi uguali, e ad essi non ho associato alcuna funzione(in quanto non so se ognuno di essi è un router o un nodo semplice).Per associare loro le corrette funzioni, devo ripartirli in router e nodi semplici associati a router, in modo qualsiasi, e in modo tale da rispettare gli ingressi iniziali, ossia in questo caso 2 router e 2 nodi per router (perchè teoricamente 6 nodi potrebbero anche corrispondere a 1 router e 5 nodi per router)

riproponendo gli esempi, manualmente in questo caso si dovrebbe arrivare ad uno di questi scenari:
scenario 1:
n(0) è router
n(1) è nodo semplice connesso a n(0)
n(2) è nodo semplice connesso a n(0)
n(3) è router
n(4) è nodo semplice connesso ad n(3)
n(5) è nodo semplice connesso ad n(3)
scenario2:
n(0) è router
n(1) è router
n(2) è nodo semplice connesso a n(0)
n(3) è nodo semplice connesso a n(0)
n(4) è nodo semplice connesso ad n(1)
n(5) è nodo semplice connesso ad n(1)

qualsiasi sia la suddivisione non mi interessa(uno dei 2 scenari proposti, o anche un altro), basta che l'algoritmo mi individua tra i 6 nodi, 2 router e gli altri 4 nodi semplici(2 associati ad un router e 2 ad un atro router)

ripeto, siccome lavorare con questi script è difficile, sono da evitare liste, ma pensavo ad una cosa + semplice del tipo partizionare ad esempio i primi nodi come router(in base al numero di router) e i restanti come nodi(quindi seguendo lo scenario 2, ma anche un approccio con lo scenario 1 mi va bene), e poi per associare ogni nodo al router fare qualcosa del tipo:
if( operazione ==x) then nodo semplice attuale è connesso a router X

[omniaforever]

nessuno?

[lupoxxx87]

hai visto il codice che ti ho postato ?
quello inserisce nell'array tutti gli elementi, e ogni nodo router è connesso a tutti i nodi successivi fino al prossimo nodo router

[cionci]

Non so se è quello che vuoi sapere...ma ci provo...

Se usi il primo metodo i router stanno in Ri = v[i * (n_nodi + 1)], gli host di un dato router si trovano Hij = v[Ri + j]

Se usi il secondo metodo i router stanno in Ri = v[i], gli host stanno in Hij = V[n_router + i * n_nodi]

[omniaforever]

hai visto il codice che ti ho postato ?
quello inserisce nell'array tutti gli elementi, e ogni nodo router è connesso a tutti i nodi successivi fino al prossimo nodo router

grazie ma non voglio ciò.avendo un vettore di nodi dev semplicemente sapere queli sono i router, quali i nodi semplici e per i nodi semplici sapere a che router sono associati

[omniaforever]

Non so se è quello che vuoi sapere...ma ci provo...

Se usi il primo metodo i router stanno in Ri = v[i * (n_nodi + 1)], gli host di un dato router si trovano Hij = v[Ri + j]

Se usi il secondo metodo i router stanno in Ri = v[i], gli host stanno in Hij = V[n_router + i * n_nodi]

sono una capra a spiegarmi. hihi
prendiamo il secondo caso che è + semplice.
se ho 6 nodi che dovrò partizionare in 2 router e 4 nodi(2 per ogni router)
posso semplicemente fare qualcosa del tipo:
for (i=0 i<numero router i++) //quindi da 0 ad 1 = i 2 router
{
n(i) è un router
}
for (i = numero router ; i < numero router*nodi per router + numero router;i++) //quindi da 2 a 5 = i 4 nodi semplici
{
n(i) è un nodo semplice associato al router n(X) (voglio esplicitare questo X in modo tale che in questo caso venga o 0 o 1, cioè gli indici dei 2 router)
}
come vedi partizionare nodi semplici e router è semplicissimo (posso prendere i primi come router e tutti gli altri come nodi semplici), solo che non so per quanto riguarda i nodi semplici come trovare il router n(X) associato.
per il nodo semplice n(i) il router n(X) associato dovrebbe venire da qualche operazione basata su indici, nnodi,nrouter o non so, che mi fa ottenere l'indice X del router da associare.
in sostanza sempre rifacendoci al nostro esempio, il secondo ciclo for si dovrebbe esplicitare in
n(2) è un nodo semplice associato al router n(0)
n(3) è un nodo semplice associato al router n(0)
n(4) è un nodo semplice associato al router n(1)
n(5) è un nodo semplice associato al router n(1)
come faccio a farglieli associare automaticamente i nodi ai vari router (dovrebbe associarne 2 al primo router e 2 al secondo), come faccio a trovare l'indice corretto del router da associare a seconda del nodo (cioè i primi 2 nodi voglio associarli al router con indice 0, gli altri 2 al router con indice 1 in questo caso.ovviamente deve valere per qualsiasi numero di router e nodi)
appunto penso che che l'indice del router da associare ad un nodo posso essere trovato con una operazione

[lupoxxx87]

grazie ma non voglio ciò.avendo un vettore di nodi dev semplicemente sapere queli sono i router, quali i nodi semplici e per i nodi semplici sapere a che router sono associati

ma guarda che nell'array ci metti un attimo a trovarli...

i = indice%router
j = parte intera di indice/router

se i=0 => j-esimo router
se i!=0 => i-esimo nodo associato al j-esimo router

una modo più semplice non so proprio trovarlo

[cionci]

Con il primo metodo dato un nodo j l'indice del corrispondente router è Ri = j - j % (n_nodi + 1)
Con il secondo metodo Ri = (j - n_router) / n_nodi

[omniaforever]

Con il primo metodo dato un nodo j l'indice del corrispondente router è Ri = j - j % (n_nodi + 1)
Con il secondo metodo Ri = (j - n_router) / n_nodi

perfetto!!era quello che mi interessava sapere

lupo grazie anche a te, la tua soluzione è anche ottima, ma se fosse stato un programma in C o java era un'altra storia, qui è un po' più complessa la cosa e preferisco gestirmela proprio come mi ha mostrato il mod ;)

[cionci]

Ri = j - j % (n_nodi + 1)

Questo può essere anche scritto così, se ti può tornare più semplice:
Ri = (j / (n_nodi + 1)) * (n_nodi + 1)
j / (n_nodi + 1) deve essere una divisione intera.

Anche qui deve essere una divisione intera:
Ri = (j - n_router) / n_nodi

[omniaforever]

rieccomi.ho un nuovo quesito da porvi.
allora, sempre nel caso 2 router e 2 nodi per router.
supponiamo che n(0) ed n(1) siano i router
n(2) n(3) nodi di n(0)
n(4) n(5) nodi di n(1)
quello che voglio fare è creare una connessione tra tutti i nodi successivi in una sottorete fino al router
ossia in questo caso dovrei avere
n(2) si connette ad n(3)
n(3) a n(0)
n(4) a n(5)
n(5) ad n(1)
cioè ogni nodo prima di arrivare al router proprio passa fra i nodi intermedi.
come faccio?
grazie

[omniaforever]

nessuno? :p

[cionci]

Non ti basta scorrere tutti i nodi di un dato router in ordine e l'ultimo collegarlo al router ?

[omniaforever]

Non ti basta scorrere tutti i nodi di un dato router in ordine e l'ultimo collegarlo al router ?
il fatto è che io non ce li ho suddivisi a priori, come avevo già detto prima.
io ho ad esempio 6 nodi da n(0) ad n(5) da suddividere in 2 router e 2 nodi per router.
poi appunto io me li suddivido in router i primi 2 e nodi semplici gli altri 4.
Con la soluzione che mi avevi dato riuscivo a connettere ogni nodo semplice al router relativo, ma adesso mi serve una cosa più complessa, in quanto i nodi( adifferenza del caso precedente per cui mi avevi dato la soluzione) non si connettono direttamente al router relativo, ma passano fra i nodi intermedi.

quindi in definitiva nel caso precedente in cui connettevo direttamente ogni nodo al router relativo avevo:
for (i=0 i<numero router i++) //quindi da 0 ad 1 = i 2 router
{
n(i) è un router
}
for (i = numero router ; i < numero router*nodi per router + numero router;i++) //quindi da 2 a 5 = i 4 nodi semplici
{
n(i) è un nodo semplice e si connette a n( (i - numerorouter) /nodiperrouter)) //si connette al router relativo
}

in questo caso come al solito per risolvere questo nuovo problema devo modificare il secondo for, in modo tale che un nodo si connetta al router relativo come l'esempio precedente solo nel caso che sia l'ultimo nodo della sottorete (in questo caso i nodi n(3) e n(5) che si connetterebbero rispettivamente al router n(0) e n(1); mentre nel caso sia un nodo non utimo si deve connettere al nodo successivo (in questo caso n(2) che si connette ad n(3) e n(4) ad n(5) )
forse un semplice if del tipo che if(n(i) è l'ultimo della catena) si connette a n( (i - numerorouter) /nodiperrouter)) ,altrimenti n(i) si connette a n(i+1).in eventuale caso qual è la condizione per verificare che sia l'ultimo di una sottorete?

[cionci]

Lo riporti al caso precedente e poi fai come ti ho detto...