CryptoByLeo/Src/DiseñoBenchs/BE64_PUB_DEC.mq5

//+------------------------------------------------------------------+
//|                                                   Base64Bench.mq5 |
//| Benchmark: decodificar Base64 con whitespace (\r\n, espacios)    |
//| embebido en cualquier posicion, segun gramatica "lax" RFC 7468.  |
//|                                                                    |
//| Competidor A: limpieza a buffer temporal + CryptDecode nativo    |
//| Competidor B: decode manual streaming, sin buffers intermedios,  |
//|               tabla de lookup, todo en un solo recorrido         |
//+------------------------------------------------------------------+
#property script_show_inputs

input int InpIterations   = 20000;   // Iteraciones por competidor
input int InpPayloadBytes = 3000;    // Bytes RAW (antes de b64) a generar para el test

//+------------------------------------------------------------------+
//| Tabla de lookup Base64 -> 6 bits.                                 |
//| 0xFF marca: caracter invalido O whitespace (ambos se tratan igual:|
//| "saltar"), simplificando el chequeo a una sola comparacion.       |
//+------------------------------------------------------------------+
const uchar g_b64_lut[256] =
 {
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3E, 0xFF, 0xFF, 0xFF, 0x3F,
  0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
  0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
  0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
 };

/* Codigo de ia... lo cambie dado qeu el competidor manaul
me parecio interenate asi que lo mejoraremos
bool  g_lut_ready = false;

void BuildLUT()
{
 ArrayInitialize(g_b64_lut, 0xFF);
 string alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 for(int i = 0; i < 64; i++)
    g_b64_lut[(uchar)StringGetCharacter(alphabet, i)] = (uchar)i;
 g_lut_ready = true;
}*/

//+------------------------------------------------------------------+
//| Genera un "raw" base64 con saltos de linea cada 64 chars (CRLF), |
//| simulando un PEM real, a partir de bytes binarios random.        |
//+------------------------------------------------------------------+
void GenerateTestInput(uchar &rawOut[], int payloadBytes)
 {
  uchar bin[];
  ArrayResize(bin, payloadBytes);
  for(int i = 0; i < payloadBytes; i++)
    bin[i] = (uchar)(MathRand() & 0xFF);

  uchar b64[];
  uchar key[];
  ArrayResize(key, 0);
  int n = CryptEncode(CRYPT_BASE64, bin, key, b64);
  if(n <= 0)
   {
    Print("Error generando base64 de prueba: ", GetLastError());
    return;
   }

// Insertar \r\n cada 64 caracteres, como un PEM real
  ArrayResize(rawOut, n + (n / 64 + 2) * 2);
  int w = 0, pos = 0;
  while(n - pos >= 64)
   {
    w += ArrayCopy(rawOut, b64, w, pos, 64);
    rawOut[w++] = '\r';
    rawOut[w++] = '\n';
    pos += 64;
   }
  if(pos < n)
   {
    w += ArrayCopy(rawOut, b64, w, pos, n - pos);
    rawOut[w++] = '\r';
    rawOut[w++] = '\n';
   }
  ArrayResize(rawOut, w);
 }



//+------------------------------------------------------------------+
//| COMPETIDOR A: limpieza a buffer temporal + CryptDecode nativo    |
//+------------------------------------------------------------------+
int DecodeB64_Native(const uchar &raw[], uchar &out[])
 {
  int rawLen = ArraySize(raw);

// Buffer temporal presized al tamaño maximo posible (== rawLen, nunca mas)
  uchar clean[];
  ArrayResize(clean, rawLen);

  int w = 0;
  for(int i = 0; i < rawLen; i++)
   {
    uchar c = raw[i];
    // Whitespace: espacio, \t, \r, \n -- se descarta
    if(c < 33)
      continue;
    clean[w++] = c;
   }
  ArrayResize(clean, w);

//uchar key[];
//ArrayResize(key, 0);
// NIQUE: mejora para b quitamos array temporal
  return CryptDecode(CRYPT_BASE64, clean, clean, out);
 }

//+------------------------------------------------------------------+
//| COMPETIDOR B: decode manual streaming, sin buffers intermedios.  |
//| Un solo recorrido de raw[], acumula 4 simbolos validos via LUT,  |
//| vuelca directo a out[] presized. Sin arrays temporales de ningun |
//| tipo, sin llamadas a funciones dentro del hot loop.              |
//+------------------------------------------------------------------+
int DecodeB64_Manual(const uchar &raw[], uchar &out[])
 {
  const int rawLen = ArraySize(raw);
  ArrayResize(out, (rawLen / 4 + 1) * 3);
  int w = 0;          // puntero de escritura en out[]
  uint acc = 0;       // acumulador de bits
  int bits = 0;      // cuantos bits validos hay en acc
  for(int i = 0; i < rawLen; i++)
   {
    //---
    const uchar c = raw[i];
    if(c < 33 || c == '=')
      continue;
    //---
    acc = (acc << 6) | g_b64_lut[c];
    bits += 6;
    if(bits >= 8)
     {
      bits -= 8;
      out[w++] = uchar(acc >> bits);
     }
   }

  ArrayResize(out, w);
  return w;
 }

//+------------------------------------------------------------------+
//| Verifica que dos buffers de salida sean identicos (sanity check) |
//+------------------------------------------------------------------+
bool BuffersEqual(const uchar &a[], const uchar &b[])
 {
  int n = ArraySize(a);
  if(n != ArraySize(b))
    return false;
  for(int i = 0; i < n; i++)
    if(a[i] != b[i])
      return false;
  return true;
 }

//+------------------------------------------------------------------+
//| Script principal                                                  |
//+------------------------------------------------------------------+
void OnStart()
 {
// BuildLUT();
  MathSrand((int)GetTickCount());

  uchar raw[];
  GenerateTestInput(raw, InpPayloadBytes);

  Print("=== Base64 Decode Benchmark ===");
  Print("Payload binario: ", InpPayloadBytes, " bytes  ->  raw b64 (con CRLF): ", ArraySize(raw), " bytes");
  Print("Iteraciones por competidor: ", InpIterations);

// --- Sanity check: ambos deben producir el mismo resultado ---
  uchar outA[], outB[];
  int resA = DecodeB64_Native(raw, outA);
  int resB = DecodeB64_Manual(raw, outB);

  if(resA <= 0)
   {
    Print("ERROR: Competidor A (nativo) fallo. GetLastError=", GetLastError());
    return;
   }
  if(!BuffersEqual(outA, outB))
   {
    Print("ERROR: Los resultados NO coinciden. A=", resA, " bytes, B=", resB, " bytes. Abortando benchmark.");
    return;
   }
  Print("Sanity check OK: ambos competidores producen el mismo resultado (", resA, " bytes).");
  Print("");

// --- Warm-up (evita medir efectos de JIT/cache frio) ---
  uchar warm[];
  for(int i = 0; i < 100; i++)
   {
    DecodeB64_Native(raw, warm);
    DecodeB64_Manual(raw, warm);
   }

// --- Benchmark Competidor A ---
  uchar tmpOut[];
  ulong t0 = GetMicrosecondCount();
  for(int i = 0; i < InpIterations; i++)
    DecodeB64_Native(raw, tmpOut);
  ulong t1 = GetMicrosecondCount();
  double usA = (double)(t1 - t0);

// --- Benchmark Competidor B ---
  ulong t2 = GetMicrosecondCount();
  for(int i = 0; i < InpIterations; i++)
    DecodeB64_Manual(raw, tmpOut);
  ulong t3 = GetMicrosecondCount();
  double usB = (double)(t3 - t2);

  Print("--- Resultados ---");
  PrintFormat("A) Nativo (clean buffer + CryptDecode): %.2f us total | %.4f us/iter", usA, usA / InpIterations);
  PrintFormat("B) Manual streaming (sin buffers temp): %.2f us total | %.4f us/iter", usB, usB / InpIterations);
  PrintFormat("Speedup B vs A: %.2fx", usA / usB);
 }
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+