Occa: Solicitud de función: agregue la opción para detener el analizador para reemplazar las variables definidas con sus valores

Desafortunadamente, todas las definiciones deben expandirse para aplicar transformaciones de código.
Los valores #define se pueden encontrar en dos lugares

raw_source.cpp

> head ~/.occa/cache/c8141715ac4e4272/raw_source.cpp 
#define  block 256

/* The MIT License (MIT)
 *

construir.json

> cat ~/.occa/cache/c8141715ac4e4272/build.json | jq .kernel.props.defines
{
  "block": 256
}

Estoy de acuerdo en que es útil hacer esto para extraer los límites reales del bucle e imagino que el analizador está diseñado para hacer esto. Sin embargo, parece poco probable que sea imposible conservar las definiciones en el código. Hacer un seguimiento de cómo se calculan los valores obviaría la necesidad de imprimir sus valores numéricos.

Es más difícil de lo que parece mantener el código y transformarlo
Define puede ser cualquier cosa, incluso código parcial

#define foo 3 +

for (int i = 0; i < foo 5; ++i) {}

Mantener las líneas #define también puede causar problemas, ya que el compilador seguirá ejecutando el preprocesador.

... y si Define es solo una constante numérica... ?

... y por qué necesitamos lógica adicional para eso ....?

Este es un ejemplo del kernel de salida.

extern "C" __global__ void _occa_ellipticPreconCoarsenHex3D_0(const int Nelements,
                                                              const double * __restrict__ R,
                                                              const double * __restrict__ qf,
                                                              double * __restrict__ qc) {
  {
    int e = 0 + blockIdx.x;
    __shared__ double s_qfff[8][8][8];
    __shared__ double s_qcff[2][8][8];
    __shared__ double s_qccf[2][2][8];
    __shared__ double s_qccc[2][2][2];
    __shared__ double s_R[2][8];
    {
      int k = 0 + threadIdx.z;
      {
        int j = 0 + threadIdx.y;
        {
          int i = 0 + threadIdx.x;
          const int id = i + j * 8 + k * 8 * 8 + e * 512;
          s_qfff[k][j][i] = qf[id];
          if ((k == 0) && (j < 2)) {
            s_R[j][i] = R[j * 8 + i];
          }
        }
      }
    }

Los núcleos están perdiendo legibilidad en la traducción. Todos estos números fueron Definidos.

Dando un paso atrás, el motivo de la solicitud de función era

hacer que el código generado sea mucho más fácil de leer

El código generado está destinado al compilador, no a los usuarios (similar a las salidas preprocesadas por el compilador). Si hay un problema de análisis, especialmente porque el analizador aún no está maduro, podría ayudar a mirar. Sin embargo, estos problemas deben resolverse con el tiempo.

Si el propósito es facilitar la depuración, acepto que debemos agregar #line para que coincida con el código fuente original

Estoy de acuerdo en que para depurar esto sería una verdadera ventaja: ¡buena idea!

Debería haber sido más claro sobre el razonamiento detrás de esta solicitud: un caso de uso importante que visualizo para las nuevas herramientas de generación de código en OCCA 1.0 es como traductor de OKL al lenguaje de subprocesamiento nativo para aplicaciones que no son de OCCA. En ese caso, será importante preservar la legibilidad ya que el código CUDA/OpenCL/HIP/OpenMP generado se separará del código OKL.

Eso suena razonable

Hay algunas características que deberán agregarse primero

• Cree variables globales a partir de definiciones numéricas pasadas como propiedades del kernel en lugar de #define
  
  
  
  • :advertencia: Ser capaz de hacerlo para todos los #defines es demasiado difícil ya que necesitaríamos rastrear dónde están definidos y qué ámbitos tocan después de las transformaciones
  
  
• [Nueva característica] Durante parser::getExpression , sustituya constexpr con sus valores
  
  
  
  • Inicialmente solo const variables
  
  
  • Ampliar a constexpr funciones
  
  
• Vuelva a agregar #define líneas en la parte superior como de costumbre

¡Gracias por contemplar la solicitud de funciones!