Eficiente cola de bytes C para analizar el flujo de bytes para paquetes de mensajes binarios

Question

Estoy intentando reemplazar lo que normalmente implementaría como un buffer circular +. La función de la cola es almacenar en búfer los bytes entrantes (por ejemplo, desde el puerto serie o alguna otra secuencia de datos), mientras que un analizador examina los bytes en la cola y detecta y extrae los paquetes de mensajes.

Criterios:

• puede crecer (es decir, no-fijos de tamaño)

• = 1 bytes pueden ser en cola a la vez

• = 1 bytes puede ser dequeued a la vez

• eficiente

Estoy tentado sólo para usar

System.Collections.Generic.Queue<byte> 

... pero no estoy seguro de si este es el tipo más eficiente de utilizar. ¿Alguna sugerencia?

¿Hay alguna forma más inteligente de hacer lo que estoy tratando de hacer? (Por ejemplo, sugerencias interesantes here)

Gracias por sus sugerencias & input.

Prembo.

Answer 1

Queue<byte> está respaldado por una byte[], pero que se vería mejor rendimiento si la copia a/desde la memoria intermedia subyacente utilizando Array.Copy en lugar de bucle a través de los métodos de puesta en cola/retirada de cola. Personalmente, si Queue<byte> no le proporciona el rendimiento que desea, entonces puede implementar su propia clase de cola que proporcione métodos QueueMultiple y DequeueMultiple.

Answer 2

Bueno, Queue<byte> será eficiente en términos de memoria. Básicamente será byte[] detrás de escena. Sin embargo, puede ser un poco incómodo trabajar con él si desea dequeuear o enquear trozos completos a la vez. Cada operación debe amortizarse O (1) para un solo byte, lo que lleva a O (n) a poner en cola o dequear un fragmento de tamaño n ... pero el factor de escala será mayor que (digamos) una copia del bloque de almacenamiento intermedio.

Answer 3

Según cómo se reciban los bytes entrantes y cómo el analizador los examine, puede considerar Queue<byte[]>.

Answer 4

Sé que no soy útil, pero puede escribir uno propio.
La parte teórica:
La cola debe estar en byte[] y 2 índices, 1 para la cabeza y 1 para la cola

 
0             n 
|----------------------------------------------------| 
       |      | 
       head      tail 

Cada vez que es necesario agregar k bytes que se mueve la cola k unidades izquierda y puso el en el nuevo espacio creó datos allí.

 
0             n 
|-------------------------------new data-------------| 
       |    |  | 
       head   new tail old tail 

Cada vez que usted necesita para hacer estallar k bytes que mover la cabeza k unidades izquierda y tomar datos desde el espacio perdido.

 
0             n 
|-------new data-------------------------------------| 
     |  |      | 
    new head head      tail 

En caso de que la cabeza y la cola colisionen, debe duplicar el tamaño del contenedor y copiar cada mitad al nuevo.

tener en cuenta: si se agrega 1234 y luego el pop 2 letras obtendrá 34

(no sé si debería marcar este puesto de wiki de la comunidad)

Answer 5

Aquí es an efficient implementation de un buffer que escribió hace un tiempo:

• de Resizeable: permite hacer cola de datos y no tirar búfer excepción de desbordamiento;
• eficiente: utiliza una única memoria intermedia y operaciones Buffer.Copy a poner en cola/datos dequeue