Casos de prueba para sumador de acarreo de ondulación de 16 bits

Digamos que queremos hacer un buen trabajo de prueba, pero sin pasar por todo el espacio 2 ^ 32 de posibles operandos. (No es posible que dicho sumador tenga un error tal que solo afecta a una combinación única de operandos, lo que requiere una búsqueda exhaustiva del espacio 2 ^ 32, por lo que es ineficiente probarlo de esa manera).

Si los agregadores individuales funcionan correctamente, y la propagación de la ondulación entre ellos funciona correctamente, entonces es correcta.

Daría prioridad a algunos casos de prueba que se centran en acentuar la ondulación del acarreo, ya que los agregadores se han probado individualmente.

Mi primer caso de prueba sería agregar 1 a 1111..1111, lo que provoca que se lleve a cabo cada bit. El resultado debe ser cero, con una extracción del bit más alto.

(Todo caso de prueba debe intentarse con ambas conmutaciones: A + B y B + A, por cierto).

El siguiente conjunto de casos de prueba agregaría 1 a varios patrones de "solo cero" como 011 ... 111, 1011 ... 11, 110111..111, ..., 1111110. La presencia de un cero debe "comer" la propagación de acarreo correctamente en esa posición de bit, de modo que todos los bits en el resultado que sean más bajos que esa posición sean cero, y todos los bits más altos sean 1 (y, por supuesto, no hay un registro final) ).

Otro conjunto de casos de prueba agregaría estos patrones de potencia de dos bits "únicos 1" a varios otros patrones: 000 ... 1, 0000 ... 10, 0000 ... 100, ..., 1000 ..000. Por ejemplo, si esto se agrega al operando 1111.1111, entonces todos los bits de esa posición de bits a la izquierda deberían borrarse, y todos los bits de abajo no deberían verse afectados.

A continuación, un caso de prueba útil podría ser agregar todas las 16 potencias de dos (los vectores "solitario 1"), así como cero, a cada uno de los 65536 valores posibles del operando opuesto (y por supuesto, conmutar y repetir).

Finalmente, repetiría las dos pruebas anteriores "solo 1" con "solo 11": todos los patrones de bits que tienen 11 incrustados en 0, en todas las posiciones posibles. De esta manera, estamos llegando a las situaciones en las que cada sumador combina dos acarreos de 1 bit y , lo que requiere que produzca 1 y que realice 1.

Siempre que sea posible, una prueba completa es una opción segura. Con 2 \ $ ^ {32} \ $ permutaciones de entrada, un chip rápido y algo de paciencia, esto podría ser factible. (A 1 prueba por nosotros, tomaría menos de 2 horas).

Cuando solo estoy 'probando un sumador' y no hay tiempo para una prueba completa, me gustaría hacer una prueba aleatoria.

Pero en su caso, usted sabe que i es un sumador ondulado, y podría incluir los acarreos en su salida. Eso significa que puede probar cada sección de forma independiente, eligiendo las entradas adecuadas. Eso significa solo unos 16 * (2 ^ 3) vectores de prueba (cada combinación de A B y acarreo, y eso para cada sección). Es una prueba de prueba pequeña, pero como puede verificar que la portadora aún tiene cobertura completa.

Hay varias suites de herramientas de banco de pruebas semiautomatizadas para VHDL; Creo que el campo se llama "prueba de equivalencia", pero supongo que desea desarrollar algo desde cero.

Tenemos computadoras rápidas que pueden recorrer todas las combinaciones posibles muy rápidamente, así que te recomiendo que no lo pienses demasiado: solo prueba cada caso. Ya que estás hablando de un sumador de 16 bits, eso significa 65536 combinaciones para la primera entrada, y 65536 para la segunda entrada. Un contador de 32 bits conectado a las entradas del sumador realizará un ciclo a través de cada combinación de entrada posible: conecte los 16 bits inferiores a una entrada y los 16 superiores a la otra entrada. Activar el contador de una señal de reloj generada a partir de un proceso de estímulo (fuera de < = '1' después de 10 ns; fuera de < = '0' después de 10 ns;)

Ahora, necesita probar para ver si la salida de su sumador es correcta. Las herramientas que tiene disponibles dependen en gran medida de su entorno. Lo más fácil de comprender es probablemente tomar la salida de su sumador, y restar la primera entrada, y luego restar la segunda entrada, y luego mirar el resultado; Si no es todo ceros, levante una bandera. VHDL tiene incorporadas funciones matemáticas y de comparación, por lo que construir un bloque VHDL que realice esta operación debería ser bastante trivial. Agregue un pestillo al final para mantener el valor, y luego puede simularlo y luego mirar el último valor del resultado de su simulación: si es 0, funciona, si es 1, no funciona.

Este es un ejercicio académico. Como tal, el problema en sí es fácil, así que lo que importa es la lección, no los aspectos específicos del problema. En este caso trivial, puede encontrar muchas formas ad hoc de probarlo con la confianza de que demostrará o refutará que el módulo funciona según lo previsto. Pero la verdadera lección en este caso es descubrir cómo producir una cobertura de prueba para algo que puede ser demasiado complejo para estar seguro de que una forma de prueba de acceso directo construida intuitivamente será confiable para completarla. No es que esas habilidades no sean útiles, de hecho, son necesarias cuando la cobertura completa no es computacionalmente práctica, pero esa no es la lección aquí, de lo contrario el problema de ejemplo se habría formulado como tal.

Entonces, escriba un banco de pruebas, conecte su uut (unidad a prueba), déle todas las entradas posibles (puede usar un bucle anidado para esto) y compare la salida con el resultado conocido, calculado utilizando la biblioteca matemática vhdl , que sabe que es correcto y utiliza el procesador de su PC para el cálculo, y si la salida es diferente, use la función de informe (o escriba en el archivo) para mostrar en la consola las entradas para las cuales la prueba falló, para que pueda Luego investigue la anomalía.

Como nota al margen, la cobertura total es en realidad imposible para una caja negra real, por lo que en realidad necesitas tener una idea del diseño. Por ejemplo, podría crear un sumador que siempre le dé la respuesta correcta para cualquier conjunto de entradas dado, a menos que las adiciones anteriores sigan un patrón específico (bienvenido al mundo de las puertas traseras de hardware), por lo que tendrá que probar un arbitrario gran cantidad de secuencias de entrada, a menos que sepa la cantidad máxima de elementos de la memoria interna, etc. Pero estoy divagando.