Vraag : De kwestie van het ontwerp, die datum van /proc opslaan

Hallo, is

This meer om wat te krijgen terugkoppelt van mijn ontwerp toen een daadwerkelijk op te lossen probleem. Ik dacht ik het een poging zou geven aangezien u kerels zo nuttige vroeger bent geweest.

Ok hier het is. Ik probeer om a. c. ++- programma te schrijven dat een momentopname van /proc gaat nemen filesystem. Tot dusver heb ik een syntactische parser geschreven om elke pid richtlijn te ontleden. De momentopname zal dan een klasse zijn die de procstructuur insluiten die ik probeer om te ontwerpen.

[ProcInfo]
  |1312--[Dir]
  |                   |
  |                   |---smap--[Dossier]
  |                   |                   |--RSS--[Gegevens]
  |                   |                   |--USS--[Gegevens]
  |                   |                   |--PSS--[Gegevens]
  |                   |---cmdline--[Dossier]
  |                   |                    |--cmd--[Gegevens]
  |                   |---netto--[Dir]
  |                                  |---sockstat6--[Dossier]
  |                                  |                         |--TCP6--[Gegevens]
  |---meminfo--[Dossier]
                         |---memtotal--[Gegevens]/> [ProcInfo] =A klasse

[Dir] klasse erven =A die een dir in proc vertegenwoordigen die zou moeten de virtuele momentopname class
[Dossier] klasse erven =A die een dossier in proc vertegenwoordigen die zou moeten de virtuele momentopname class
[Gegevens] klasse erven =A die de gegevens vertegenwoordigen die de syntactische parserreturns.

class Momentopname
{/> de virtuele leegte
};

class Dir: openbare Snapshot
{
…
…
….privé
: /> norm *mpData;
};

class- Dossier: openbare Snapshot
{
…
…
….privé
: /> norm *mpData;
};


class ProcInfo: openbare Dir
{
…
….
};

I zou dan dit in een in werking gestelde draad willen gebruiken om de 10 seconde en het nemen van een momentopname van /ptoc

ProcHandler proc; *procInfo
ProcInfo = proc.snapshot ();

Dir pidSnapshot = procInfo->getPid (1312);
Data- gegevens = pidSnapshot.get (ProcInfo:: RSS);
int rss = data.toInt ();
string sRss = data.toString ();

File memSnapshot = procInfo->getSystem (ProcInfo:: MEM);
Data- gegevens = memSnapshot.get (ProcInfo:: MEMTOTAL);
int mem = data.toInt ();
string sMem = data.toString ();

delete procInfo;

Any- commentaren op dit ontwerp veel gewaardeerd worden zelfs kleine degenen I enkel behoefte om wat te krijgen terugkoppelen. Ik heb bij dit ontwerp aan lang gestaard en ik denk dat ik mijn zelf binnen aan dit het ontwerp heb gesloten. Ik heb sommige nieuwe ogen nodig om een blik bij het te nemen en misschien kunnen zij sommige problemen zien of misschien een veel betere design.

Antwoord : De kwestie van het ontwerp, die datum van /proc opslaan

Schijnt o.k. aan me, maar aangezien u om nieuwe ideeën vroeg, hier gaat --

- Als kwestie van pref/smaak zou ik veel eerder de omzettingenniet-leden als houden, zodat moet ik de interface verontreinigen en geen nieuwe omzetting laten aan het systeem gemakkelijk worden toegevoegd. Maar zoals ik zei, die een kwestie van smaak misschien ben.

Zet om (Gegevens D);
Zet om (D);

- Aangezien u over het minimaliseren van serverreizen en bandbreedte sprak en toevallig de „momentopname“ uitdrukking gebruikte, is het natuurlijk om ook aan „differentiële momentopnamen“ te denken. Zo is het idee dat u een primaire momentopname neemt.

Dir pidSnapshot = procInfo->getPid (1312);
Het verschil van SnapShot* = pidSnapshot->difference ();

Momentopname:: verschil ();
Momentopname:: applyDifferential (Snapshot* D)

Zodat de manier, slechts waarden die verandering sinds laatste hebben vangt zal zijn teruggekeerd en dat reusachtige besparingen in termen van prestaties kan veroorzaken.

- Bent u zeker proc filesystem hebt geen symbolische verbindingen (bedoel ik de zelfde entiteit die verschijnt onder veelvoudige bijenkorven)? Als ja, dan is o.k. het om twee exemplaren van het zelfde gegeven te houden. Ik veronderstel het niet, zolang de waardevoorwerp van de momentopname enkel veel van belang is.

- Eerder dan het hebben van het getPid () enz. soort zeer specifieke accessors, zou het lonender zijn als u in de basisklasse kon hebben een generische reeks vondst () methodes als zegt

virtuele Momentopname Snapshot*:: vind (koordkind) {
}

Hoe ook over de basis van de Momentopname die kinderen heeft

klasse SnapshotContainer: openbare Momentopname
{
virtuele Momentopname Snapshot*:: vind (koordkind) {
}
privé:
  norm: kaart *mpData;
};

- Nuttig zou zijn, als u ook een lichte maar belangrijke variatie voor vondst (), roept het verstrekt de plaats bepaalt van () die een weg (eerder dan een naam) neemt en het vuile werk van het doen van het oversteken doet.

// de weg is in deze vorm, /root/net/sockstats/tcpip6
De Momentopname van Snapshot*:: bepaal van de plaats (koordweg) {
}

- De belangrijkste verandering zou die ik zou aanbrengen de tot momentopname een verwijzing geteld voorwerp moeten maken en terugkeerde slim/refptr aan de momentopname eerder dan ruwe wijzers. Dat werkelijk heel wat macht geeft, vooral wanneer u kinderen wilt kunnen halen en hen rond houden (misschien)

klassen Momentopname: openbare RefCounted // ziet Poco:: RefCounted voor ref.
{
}

typedef RefCountedPtr RefSnapshot;

Hoop deze hulp…