Regroupements d'objets par adresse

**petitours** · 31/08/2016, 19h04

anapurna bonjour

Je n'ai rien compris au raisonnement là...
Un objet/paramètre ne fait pas forcément 8 octet, il peut en faire 1, 2, 4 ou 8

Si j'ai 100octets positionnés aux adresses 0, 1000 ,2000,3000...99000 il me faudrait obligatoirement 100 cycles pour les lire 1 par un.

PS : j'ai de de l'ordre de 100 objets mais je peux en avoir 1 seul comme je peux en avoir 1000 ou 2000 (ce sera très rare) mais je ne pense pas que ça change grand chose au raisonnement.

**tbc92** · 31/08/2016, 19h19

Pour la compréhension du problème :

Si tu as 1 octet à transférer à l'adresse 1000, et 1 autre, à l'adresse 1030, tu t'imposes de faire 2 envois séparés, ou bien un envoi avec le paquet 1000 à 1030 ; tu t'interdis de faire un seul envoi avec les 2 octets 'accolés'.

C'est une contrainte surprenante, que Anapurna n'a pas prise en compte.

**petitours** · 31/08/2016, 19h25

la raison est très simple
le protocole de communication, propriétaire, qui ressemble fort à du MODBUS en "plus gros", permet de demander de récupérer X octets à partir de l'adresse Y

On sait faire "Merci de m'envoyer X octets à partir de l'adresse Y => (attente + timeout ) ou récupération de la réponse
on ne sait pas faire "Merci de m'envoyer ce qui se trouve aux adresses A,B,C,D et E"

c'est là tout l'intéret de l'optimisation, sinon il suffirait de demander le maximum d'objets/paramètres à chaque cycle.

**anapurna** · 31/08/2016, 19h30

salut

comment connais tu les adresses sans avoir déjà lu ton espace mémoire ?
en fait j'ai essayé de raisonner a l'envers j'ai 100 objets qu'elle serait la place maxi que je prendrais et avec une limite de 250 combien me faudrait il de segment

en fait j'essai de trouver des elements pour équilibrer le graphe sans être obligé de vérifier toutes les solutions sinon tu n'as pas fini

**petitours** · 31/08/2016, 19h37

L'espace mémoire de 100 000o est imposé par le protocole de com
et l'appareil qui cause avec ce protocole a une "map" des paramètres qu'il met à disposition
et l'utilisateur choisi dans cette map les paramètres qu'il veut récupérer.
=> ça donne la liste qui nous intéresse.

L'optimisation dont on parle ici consiste en pratique à transformer les souhaits de l'utilisateur en une série de cycles de lecture. L'optimisation est nécessaire parce que sinon on est trop limité en bande passante.

PS : A l'idée de virer l'appareil et de prendre un truc qui cause plus vite et avec un protocole moins fouareu j'y ai pensé comme vous

mais non, pas possible

**tbc92** · 31/08/2016, 20h04

Tu dis :
On sait faire : " Merci de m'envoyer X octets à partir de l'adresse Y "
Ok.

Mais le matériel distant, pour pouvoir faire ça, vient de recevoir une information, il vient de recevoir les 2 valeurs X et Y.
Qu'est-ce qui t'empêche de faire :
1. Je bloque une zone-mémoire de 250 octets consécutifs,
2. Je copie dans cette zone les 2 octets qui étaient à l'adresse 510-5411 + etc etc et je copie ainsi tous les octets 'intéressants' Sur la base de ton fichier exemple, on avait 159 octets à traiter, on les regroupe tous à un endroit.
3. On a ainsi un seul envoi à faire au matériel distant.

Tout ça pour éviter un travail d'optimisation.

**petitours** · 31/08/2016, 22h11

le matériel je ne lui envois "rien", je ne fais que lui demander de me répondre ce qu'il a de l'adresse X à l'adresse X +NombreOctetVoulu.
Ma liste que je veux optimiser, c'est la liste de ce que je veux récupérer, pas la liste de ce que je dois envoyer.

...ou alors je n'ai pas compris la réponse

Merci

**tbc92** · 31/08/2016, 23h26

ok très clair

**tbc92** · 01/09/2016, 13h40

Pour l'optimisation proprement dite, c'est du parcours d'arbre. Mais avec en fait un nombre relativement limité de scénarios à analyser.
Exemple, on a 200 paquets. On a donc un arbre à 199 niveaux :
Niveau i = Est-ce que le paquet n°i et le paquet n° (i+1) sont envoyés ensemble ( R(i) = 0 ) ou séparément ( (R(i) =1 )
Donc théoriquement 2^199 possibilités à analyser.
Mais dans la pratique, ça va nettement se simplifier.
1er niveau : 2 options possibles R(1) = 0 ou 1
2ème niveau : 4 options possibles : (0,0) , (0,1), (1,0) ou (1,1)
J'explique ma notation : (0,0) : Ca veut dire que dans ce scénario, le paquet 1 est envoyé avec le paquet 2 (c'est le premier 0), et que le paquet 2 est envoyé avec le paquet 3 (c'est le 2ème 0)
(1,1) : Ca veut dire que le paquet 1 est envoyé séparément du paquet 2 (c'est le premier 1), et que le paquet 2 est envoyé séparément du paquet 3 (c'est le 2ème 1)

Mais entre (0,1) et (1,1) , on va tout de suite pouvoir comparer quelle option est la plus coûteuse des 2, et supprimer définitivement cette branche de notre arbre.
On se retrouve donc avec 3 scénarios à analyser, au lieu de 4.

Et ainsi de suite : A chaque niveau, dans un parcours d'arbre classique, le nombre de branches se multiplie par 2. Ici, le nombre de branches ne se multiplie pas par 2, il augmente de 1 (voire il diminue dans certains cas).

Dans mon premier message , je parlais d'un traitement préalable pour scinder le problème en sous-problèmes ; ce traitement préalable est même totalement inutile.

**petitours** · 01/09/2016, 14h04

J'allais prendre le café, je vais me plonger dedans pour lire cette réponse fort alléchante mais pas bien comprise...pour le moment

merci

**anapurna** · 01/09/2016, 16h09

salut

pour la construction d'arbre il te suffit de parcourir ta liste d'objet
et de creer un arbre
Pour chaque obj on verifie les suivant que l'on ajoute tans que l'adresse de Fin du nouvel Objet - l'adresse du debut de l'objet de reference est < 250
cela devrais déjà pas mal te simplifier la vie

ensuite tu sélectionnes les branches ayant un nombre max d'objet
tu creer un autre arbre avec la branche sectionnée

tout les objet sélectionnes tu les retire de tes branches restant du premier arbre et tu
réitère le choix de la branches avec le max d'objet

dans l'exemple que tu nous a fournis je réduit a 14 paquet

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
1(2);2(3);3(5);4(8);5(14);
6(1);7(5);8(6);9(7);10(8);11(9);12(21);13(32);14(44);15(55);16(58);17(69);18(71);19(72);20(74);21(75);22(77);
23(1);24(4);25(7);26(9);27(10);28(12);29(16);30(20);
31(2);32(103);33(115);34(136);35(137);36(139);37(141);38(143);39(147);40(150);41(156);42(159);43(162);44(165);45(168);46(171);47(175);48(178);49(184);50(196);51(201);52(207);53(212);54(218);55(230);56(235);
57(2);58(103);59(205);
60(1);61(13);62(114);63(115);64(216);65(217);
66(1);67(2);68(103);69(104);70(205);71(207);
72(2);73(4);74(106);75(108);76(210);77(212);
78(1);79(103);80(204);
81(2);82(103);83(205);
84(1);85(103);86(204);
87(2);88(103);89(205);90(216);
91(2);92(103);93(205);
94(1);

**anapurna** · 02/09/2016, 16h47

salut
voici grosso modo le pseudo code pour l'optimisation

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
DEBUT
  // Creation de l'arbre
  Arbre = CreateArbre;
  POUR i DU PREMIER_ELT(LstOBJ) AU  DERNIER_ELT(LstOBJ) FAIRE
     j := i+1 ;
     Termine := FAUX;
     Branche  = CreateBranche;
     delt := LstOBJ[i].adrFin- LstOBJ[i].adrDeb;
     SI delt  <=  250 ALORS
        AjouteFeuille(Branche,LstOBJ[j])
     SINON
        Termine := VRAI;
     FINSI
 
 
    TANSQUE PAS(Termine) and J<=DERNIER_ELT(LstOBJ) FAIRE
       delt :=  (LstOBJ[j].adrFin - LstOBJ[i].adrDeb );
       SI delt  <=  250 ALORS
         AjouteFeuille(Branche,LstOBJ[j])
       SINON 
         Termine = VRAI;
       FINSI
       j=J+1
    FINTANSQUE;
    AjouteBranche(Arbre,Branche);
  FINPOUR;
 
  /// Ici la selection des branche ayant le max d'objet
   ArbreFinal =CreateArbre;
   Termine := False ;
  TANSQUE  PAS(Termine) FAIRE
    id = GetBrancheMaxObj(Arbre);
    SI id <> -1 ALORS
       Branche = GetBranche(id,Arbre);
       AjouteBranche(ArbreFinal,Branche);
       RetireObjdansArbre(id,Branche,Arbre);
     SINON
       Termine := VRAI;
     FINSI 
  FINTANSQUE
   AfficheArbre(ArbreFinal)
 
FIN

**petitours** · 02/09/2016, 16h54

Bonjour

Dsl si je n'ai pas fait (encore ) l'effort d'assimiler vos retours mais il y a eu un gros schmilblick dans mon entourage et je suis un peu bousculé dans mes priorités là...
a très bientôt

Merci

**tbc92** · 06/09/2016, 23h29

J'essaie de me mettre à Python, et comme l'exercice m'intéressait, je l'ai fait en Python. J'ai posté mon code sur le forum python pour avoir des retours.
J'ai vaguement testé, et je pense qu'en l'état, c'est correct.

**anapurna** · 07/09/2016, 18h15

salut

ce qui donne combien de paquet sur son jeux d'essai ?

Regroupements d'objets par adresse

Algorithmes et structures de données

Discussions similaires

Partager

Partager