Pergunta : Edição de projeto, armazenando a data de /proc

Olá!, o

This é mais para conseguir a algum gabarito de meu projeto então um problema real resolver. Eu pensei que eu lhe daria uma tentativa desde que você indivíduos estêve mais adiantado tão útil. o

Ok aqui é. Eu estou tentando escrever o programa da A.A. ++ que está indo tomar um instantâneo do filesystem de /proc. Eu tenho escrito até agora um parser para analisar gramaticalmente cada diretriz orientadora do pid. O instantâneo será então uma classe que encerra a estrutura do proc que eu estou tentando projetar.
do

[ProcInfo]  |-----1312--
[de Dir]  |                   |
  |                   |---smap--
[da lima]  |                   |                   |--RSS--
[dos dados]  |                   |                   |--USS--
[dos dados]  |                   |                   |--PSS--
[dos dados]  |                   |---cmdline--
[da lima]  |                   |                    |--cmd--
[dos dados]  |                   |---rede--
[de Dir]  |                                  |---sockstat6--
[da lima]  |                                  |                         |--TCP6--
[dos dados]  |---meminfo--
[da lima]                         |---memtotal--A classe do =A do

[dos dados] [ProcInfo] que representa o proc que deve herdar a classe virtual do =A do class
do instantâneo [Dir] que representa um dir no proc que deve herdar a classe virtual do =A do class
do instantâneo [lima] que representa uma lima no proc que deve herdar a classe virtual do =A do class
do instantâneo [dados] representando os dados esses o
do instantâneo do parser returns.

class {vácuo virtual do
adiciona (Snapshot*) = 0;
};

class Dir : Snapshot
{
do
do
……….
confidencial:
STD: map;
}; lima do

class: Snapshot
{
do
do
……….
confidencial:
STD: map;
};


class ProcInfo : Dir
{
do
…….
}; o

I gostaria então de usar este em uma linha funciona cada segundo 10 e tomada de um instantâneo do proc do

ProcHandler de /ptoc; *procInfo do
ProcInfo = proc.snapshot (); pidSnapshot do

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

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

delete procInfo;os comentários do

Any neste projeto seriam mesmo que pequenos muito apreciados eu apenas preciso de receber de volta alguma alimentação. Eu tenho olhado fixamente neste projeto a por muito tempo e eu penso que eu tenho fechado meu auto dentro a este o projeto. Eu preciso alguns olhos novos de olhar ele e talvez podem ver alguns problemas ou talvez um design.


class= do

Resposta : Edição de projeto, armazenando a data de /proc

Parece aprovado a mim, mas desde que você pediu idéias novas, vai aqui --

- Porque uma matéria de pref/gosto mim muito um pouco manteria os non-members das conversões como, assim que eu não tenho que poluir a relação e não deixo nenhuma conversão nova ser adicionado facilmente ao sistema. Mas como eu disse, aquela é uma matéria de gosto talvez.

Converso (dados d);
Converso (d);

- Desde você falou sobre desengates e a largura de faixa de minimização do usuário e usou coincidente a frase do “instantâneo”, ele é natural para pensar igualmente “de instantâneos diferenciais”. Assim a idéia é que você toma um instantâneo preliminar.

pidSnapshot de Dir = procInfo->getPid (1312);
Diferença = pidSnapshot->difference de SnapShot* ();

Instantâneo:: diferença ();
Instantâneo:: applyDifferential (Snapshot* d)

De modo que maneira, somente valores que têm a mudança desde que a última captação será retornada e que podem causar economias enormes nos termos do desempenho.

- É você certo o filesystem do proc não tem as ligações simbólicas (eu significo a mesma entidade que aparece sob colmeia múltiplas)? Se sim, é então aprovada manter duas cópias da mesma referência. Eu supor que não importa muito, contanto que um objeto do valor do instantâneo apenas.

- Um pouco do que tendo o tipo de accessors muito específicos, do getPid () etc. seria mais de valor se você poderia ter na classe que baixa um jogo genérico de métodos do achado () como diz

instantâneo virtual de Snapshot*:: achado (criança da corda) {
}

Igualmente como sobre a base do instantâneo que tem crianças

classe SnapshotContainer: instantâneo público
{
instantâneo virtual de Snapshot*:: achado (criança da corda) {
}
confidencial:
  STD: *mpData do mapa;
};

- Ser útil, se você igualmente fornece uma variação ligeira mas importante para o achado (), chamam-no encontram () o esse toma um trajeto (um pouco do que um nome) e faz o trabalho sujo de fazer o atravessamento.

o trajeto de // está neste formulário, /root/net/sockstats/tcpip6
Instantâneo de Snapshot*:: localizar (trajeto da corda) {
}

- A mudança a mais importante que eu faria seria fazer ao instantâneo um objeto contado referência e retornado um esperto/refptr ao instantâneo um pouco do que ponteiros crus. Isso dá realmente muito poder, especialmente quando você quer poder buscar crianças e as manter em torno (talvez)

instantâneo da classe: RefCounted público // vê Poco:: RefCounted para a referência.
{
}

typedef RefCountedPtr RefSnapshot;

Esperar este a ajuda…