Pergunta : Como diagnosticar erros físicos & lógicos do disco rígido?


 Nós temos um usuário de Dell que tenha 6 movimentações físicas.

As movimentações são configuradas using o RAID

O ósmio é configurado com RAID 1
As movimentações dos dados são configuradas com RAID 5

Nós estamos começ alguns erros da unidade de disco.


1.  Como eu sei se os erros de disco são relacionados ao disco físico ou ao disco lógico?

2.  Os erros de disco físicos podem ser fixos, qualquer um substituindo as movimentações após ter suportado dados,
     agora se seu um erro lógico, como repará-lo?

3.  Pode haver um erro de disco lógico devido à configuração imprópria do RAID das movimentações?

4. Pode haver um erro de disco lógico devido à incompatibilidade entre movimentações da ferragem?

5.  a ferragem é 64-bit, sistema de exploração que nós carregamos somos Microsoft Windows 2008 (de 32 bits).

6. Como diagnosticar se há alguma corrupção do RAID ou alguma edição lógica do disco?

Resposta : Como diagnosticar erros físicos & lógicos do disco rígido?

Bem, dentro

      {33, “B”}, {22, “C”}, {22, “D”}, {44, “E”}, {22, “D”}

você tem que entrada muito duplicada - apenas removê-la depois que é classificada, por exemplo.
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:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:

#include  
#include  
#include  
#include  
#include  
#include  
#include  

using namespace STD;

struct StudentAttempt
{
   distância do int;
   studentName da corda;
};

bool cmpEntry (StudentAttempt deixado, direita de StudentAttempt) {
   == do retorno right.studentName do && left.studentName do == right.distance de left.distance;
}
cmpAttempts do bool (StudentAttempt deixado, direita de StudentAttempt) {
   se (left.distance < right="">& v, StudentAttempt& sa do const, stringstream& ss) {

   vetor:: const_iterator i = v.begin ();
  size_t SZ = 0;
  o bFirst do bool = retifica;

  quando (i! = v.end ()) {

    se (isDistEqual (*i, sa)) {
    
      se (! studentName dos ss do bFirst <>);
      ++sz;
    }

    ++i; 
    bFirst = falso;
  }

  SZ do retorno;
}
 

cano principal do int () {

   throwDist de StudentAttempt [] = {
      {50, “A”},      {22, “A”},      {16, “B”},      {44, “C”},
      {33, “D”},      {34, “E”},      {22, “F”},      {21, “G”},
      {49, “A”},      {5, “B”},      {2, “C”},      {22, “A”},
      {33, “B”},      {22, “C”},      {22, “D”},      {44, “E”}, {22, “D”}
   };


   jogo segurado;

   int len = sizeof) (do throwDist/sizeof (throwDist [0]);

   dist do vetor (o throwDist, throwDist + len);
   vetor:: iterator ele = dist.begin ();

   sorte (dist.begin (), dist.end (), cmpAttempts);

   original (dist.begin (), dist.end (), cmpEntry); // remove as duplicatas idênticas do vetor classificado


   para (; ele! = dist.end (); it++) {

      stringstream ss;

      pares:: iterator, bool> p = handled.insert (it->distance);

      se (! p.second) continuam; // já segurado

      se (0  < printAllEqual="">
Outras soluções  
 
programming4us programming4us