Descrição do comprimento do nível de byte
Pergunta
Eu tenho um protocolo que requer um campo de comprimento de até 32 bits e deve ser gerado em tempo de execução para descrever quantos bytes estão em um determinado pacote.
O código abaixo é meio feio, mas eu estou querendo saber se isso pode ser refatorado para ser ligeiramente mais eficiente ou facilmente compreensível.O problema é que o código só irá gerar bytes suficientes para descrever o comprimento do pacote, portanto menos de 255 bytes = 1 byte de comprimento, menos de 65535 = 2 bytes de comprimento etc...
{
extern char byte_stream[];
int bytes = offset_in_packet;
int n = length_of_packet;
/* Under 4 billion, so this can be represented in 32 bits. */
int t;
/* 32-bit number used for temporary storage. */
/* These are the bytes we will break up n into. */
unsigned char first, second, third, fourth;
t = n & 0xFF000000;
/* We have used AND to "mask out" the first byte of the number. */
/* The only bits which can be on in t are the first 8 bits. */
first = t >> 24;
if (t) {
printf("byte 1: 0x%02x\n",first );
byte_stream[bytes] = first; bytes++;
write_zeros = 1;
}
/* Now we shift t so that it is between 0 and 255. This is the first, highest byte of n. */
t = n & 0x00FF0000;
second = t >> 16;
if (t || write_zeros) {
printf("byte 2: 0x%02x\n", second );
byte_stream[bytes] = second; bytes++;
write_zeros = 1;
}
t = n & 0x0000FF00;
third = t >> 8;
if ( t || write_zeros) {
printf("byte 3: 0x%02x\n", third );
byte_stream[bytes] = third; bytes++;
write_zeros = 1;
}
t = n & 0x000000FF;
fourth = t;
if (t || write_zeros) {
printf("byte 4: 0x%02x\n", fourth);
byte_stream[bytes] = fourth; bytes++;
}
}
Solução
Na verdade, você está fazendo apenas quatro cálculos, então legibilidade parece muito mais importante aqui do que eficiência.Minha abordagem para tornar algo assim mais legível é
- Extraia código comum para uma função
- Junte cálculos semelhantes para tornar os padrões mais óbvios
- Livre-se da variável intermediária print_zeroes e seja explícito sobre os casos em que você gera bytes mesmo que sejam zero (ou seja,o byte anterior era diferente de zero)
Transformei o bloco de código aleatório em uma função e alterei algumas variáveis (os sublinhados estão me causando problemas na tela de visualização do markdown).Eu também presumi que bytes está sendo passado, e quem está passando nos passará um ponteiro para que possamos modificá-lo.
Aqui está o código:
/* append byte b to stream, increment index */
/* really needs to check length of stream before appending */
void output( int i, unsigned char b, char stream[], int *index )
{
printf("byte %d: 0x%02x\n", i, b);
stream[(*index)++] = b;
}
void answer( char bytestream[], unsigned int *bytes, unsigned int n)
{
/* mask out four bytes from word n */
first = (n & 0xFF000000) >> 24;
second = (n & 0x00FF0000) >> 16;
third = (n & 0x0000FF00) >> 8;
fourth = (n & 0x000000FF) >> 0;
/* conditionally output each byte starting with the */
/* first non-zero byte */
if (first)
output( 1, first, bytestream, bytes);
if (first || second)
output( 2, second, bytestream, bytes);
if (first || second || third)
output( 3, third, bytestream, bytes);
if (first || second || third || fourth)
output( 4, fourth, bytestream, bytes);
}
Sempre um pouco mais eficiente, e talvez mais fácil de entender seria esta modificação nas últimas quatro instruções if:
if (n>0x00FFFFFF)
output( 1, first, bytestream, bytes);
if (n>0x0000FFFF)
output( 2, second, bytestream, bytes);
if (n>0x000000FF)
output( 3, third, bytestream, bytes);
if (1)
output( 4, fourth, bytestream, bytes);
Concordo, entretanto, que compactar esse campo torna a máquina de estado receptora excessivamente complicada.Mas se você não puder alterar o protocolo, esse código será muito mais fácil de ler.
Outras dicas
Você realmente deve usar um campo de largura fixa para o seu comprimento.
- Quando o programa na extremidade receptora precisa ler o campo de comprimento do seu pacote, como ele sabe onde o comprimento termina?
- Se o comprimento de um pacote puder atingir potencialmente 4 GB, uma sobrecarga de 1 a 3 bytes realmente importa?
- Você vê o quão complexo seu código já se tornou?
Experimente este ciclo:
{
extern char byte_stream[];
int bytes = offset_in_packet;
int n = length_of_packet; /* Under 4 billion, so this can be represented in 32 bits. */
int t; /* 32-bit number used for temporary storage. */
int i;
unsigned char curByte;
for (i = 0; i < 4; i++) {
t = n & (0xFF000000 >> (i * 16));
curByte = t >> (24 - (i * 8));
if (t || write_zeros) {
printf("byte %d: 0x%02x\n", i, curByte );
byte_stream[bytes] = curByte;
bytes++;
write_zeros = 1;
}
}
}
Não tenho certeza se entendi sua pergunta.O que exatamente você está tentando contar?Se bem entendi, você está tentando encontrar o byte diferente de zero mais significativo.
Provavelmente é melhor usar um loop como este:
int i;
int write_zeros = 0;
for (i = 3; i >=0 ; --i) {
t = (n >> (8 * i)) & 0xff;
if (t || write_zeros) {
write_zeros = 1;
printf ("byte %d : 0x%02x\n", 4-i, t);
byte_stream[bytes++] = t;
}
}