Ejecutando una ecuación larga en un ciclo de reloj [cerrado]

Dos pensamientos:

• Asegurarse de que puedes usar poderes de 2 (y una sugerencia para hacerlo);
• Ayudando a la herramienta de síntesis.

A. Haciendo poderes de dos.

Desafortunadamente, un simple cambio en las potencias de dos te hace cambiar de 2228 a 4096 y de 68 a 128. Eso requeriría casi cuatro veces el rango de memoria ...

Podrías dividir 2228 en 2048 + 180 dando como resultado 2048 + 256, y dividir 68 en 64 + 4 (ya potencias de dos). Necesitará reorganizar sus datos y probar qué ecuación usar en base a leaf_data, por ejemplo:

if(leaf_data[...]<30) then 
     vip_rom_addr_out_1 = (2048*( {total_tree_cnt[5:0], 1'b0} )) +
    + 75 + (now_i_1 - 15)*68 + leaf_cnt;
else 
     vip_rom_addr_out_1 = base_adr+(256*( {total_tree_cnt[5:0], 1'b0} )) +
    + 75 + (now_i_1 - 15)*68 + leaf_cnt;
endif    

Las ecuaciones anteriores necesitan ser reelaboradas, el análisis necesita algo de trabajo. El código resultante será más complejo de entender, pero más rápido de ejecutar.

También tengo en cuenta que el número de entradas para leaf_cnt ya es una potencia de 2; podría reemplazar su 2228 * ... con (16 * 2 ^ n) * leaf_cnt y sumar con total_tree_cnt en su lugar.

Para reorganizar sus datos, escriba un pequeño programa de utilidad en el idioma que prefiera y valide su fórmula en ese programa (verificando los resultados conocidos para los valores de entrada dados).

B. Ayuda a la herramienta de síntesis.

Es realmente más eficiente escribir sus expresiones en términos de los bloques informáticos que espera en lugar de introducir una expresión compleja en la herramienta de síntesis.

Por ejemplo, no debes escribir:

if(leaf_data[...]<30) then 
     vip_rom_addr_out_1 = (2048*( {total_tree_cnt[5:0], 1'b0} )) +
    + 75 + (now_i_1 - 15)*68 + leaf_cnt;
else 
     vip_rom_addr_out_1 = base_adr+(256*( {total_tree_cnt[5:0], 1'b0} )) +
    + 75 + (now_i_1 - 15)*68 + leaf_cnt;
endif  

pero

vip_rom_addr_out_1a = (2048*( {total_tree_cnt[5:0], 1'b0} )) +
    + 75 + (now_i_1 - 15)*68 + leaf_cnt;
vip_rom_addr_out_1b = base_adr+(256*( {total_tree_cnt[5:0], 1'b0} )) +
    + 75 + (now_i_1 - 15)*68 + leaf_cnt;

if(leaf_data[...]<30) then 
     vip_rom_addr_out_1 = vip_rom_addr_out_1a;
else 
     vip_rom_addr_out_1 = vip_rom_addr_out_1b;
endif

Esta segunda alternativa indicará la herramienta de síntesis que espera que cree dos módulos de cómputo y un multiplexor que probablemente sea más eficiente que un gran bloque de lógica.

Factorizar su expresión también ayudará a reutilizar recursos, etc.:

leaf_offset=75 + (now_i_1 - 15)*68 + leaf_cnt;
vip_rom_addr_out_1a = (2048*( {total_tree_cnt[5:0], 1'b0} )) +
    + leaf_offset;
vip_rom_addr_out_1b = base_adr+(256*( {total_tree_cnt[5:0], 1'b0} )) +
    + leaf_offset;

Tenga en cuenta que no hay una estructura predefinida para una suma de tres términos, solo para dos. Por lo tanto, asegurarse de que solo suma dos términos a la vez ayuda a que la herramienta reconozca el sumador y establezca la prioridad. Si suma 4 términos, sumarlos dos por dos y luego el resultado de estos dos resultados intermedios.

Si algunos de los valores corresponden a una configuración que no cambia durante un tiempo, debería poder limitar su influencia negativa en la frecuencia (encerrándolos en un registro, indicando a su herramienta que suponga que la señal es estable para el análisis de tiempo, ...).

Estoy de acuerdo en que las herramientas optimizan, pero no tanto como pensarías para la síntesis de hardware. Después de la síntesis, asegúrese de que la herramienta haya creado los sumadores, multiplicadores, multiplexores, etc. esperados. De lo contrario, verifique la documentación de pragmas que puede agregar a su código fuente.

C. El mismo tipo de trabajo es necesario para la tubería. En lugar de definir lo anterior como resultados intermedios no sincronizados, tendrá que cronometrarlos (es posible que también se deban canalizar otras señales).

D. Sepa cuánto está por debajo de alcanzar los 50MHz y dónde pierde el tiempo de cálculo. Recuerdo que aceleré los circuitos por un factor de dos y reduje su tamaño en dos con técnicas como la anterior. La aceleración puede ser bastante alta si puedes introducir multiplicaciones con factores de dos (al final solo tienes unas pocas sumas y un multiplexor). Intente calcular la ganancia que puede lograr y determine si necesita canalización o no.

¿Qué tan importante es que uses esas direcciones específicas y pongas todo eso en una RAM? Considere la posibilidad de dividir las cosas de manera diferente para que pueda reemplazar todas las constantes en esa ecuación con potencias de dos. Esto eliminará la necesidad de multiplicadores de hardware y podrá ejecutar la computación en un solo ciclo de reloj. Además, la partición del árbol en múltiples RAMs de bloques podría simplificar el cálculo de la dirección al eliminar algunas de las compensaciones que se agregan o restan.