Fujitsu Bizkaia#

Vista general#

Fujitsu Bizkaia es un provider de HPC que da a tus solvers acceso a un clúster de supercomputación de Fujitsu alojado en Bizkaia. El clúster se gestiona con Slurm, así que tu solver no calcula nada por sí mismo: envía un job por lotes al clúster, espera a que termine y devuelve la salida.

El clúster ofrece dos tipos de cómputo:

Partición	Qué es	Uso típico
`da`	Nodos con GPU y acceso al Digital Annealer de Fujitsu	Problemas de optimización combinatoria formulados como QUBO, y cargas de trabajo con GPU
`a64`	Nodos con CPU ARM (A64FX)	Cargas intensivas en CPU y vectorizadas

El Digital Annealer es un procesador especializado en optimización combinatoria a gran escala. No es un ordenador cuántico de puertas lógicas: usa una arquitectura digital inspirada en la computación cuántica para explorar el espacio de soluciones de problemas formulados como QUBO (Quadratic Unconstrained Binary Optimization).

Nota

Esta es la página específica del provider. La API del cliente, las opciones del job y el formato de los resultados son iguales para todos los providers de HPC y están documentados en Cómo crear un solver de HPC: lee primero esa página y vuelve aquí para lo específico de este clúster.

Cómo funciona#

El clúster está en una red privada y no es accesible desde internet. No tienes que ocuparte de eso: cuando tu solver usa el provider Fujitsu Bizkaia, la plataforma, antes de que se llame a tu run():

Levanta una VPN hacia la red privada.
Inicia sesión en el clúster y prepara el acceso a Slurm.
Inyecta las credenciales del clúster y sus valores de planificación por defecto como variables de entorno, que el cliente de HPC lee por ti.

Tu run() → envía un script → cliente de HPC → Slurm a través de la VPN → el clúster lo ejecuta en un nodo da o a64 → la salida del job vuelve a tu run().

Solo se ejecuta en la plataforma

Los solvers que usan este provider no se pueden ejecutar en local con python app.py. La VPN, las credenciales del clúster y el cliente de HPC solo existen dentro del entorno de ejecución de QCentroid. Puedes desarrollar la lógica del job en local si quieres, pero prueba el solver completo en la plataforma.

Crear un solver para Fujitsu Bizkaia#

1. Habilita el provider#

Ve a la sección Providers, busca Fujitsu Bizkaia y pulsa Enable.

Cuando se te pida, añade el usuario y la contraseña del clúster que recibiste del equipo de Fujitsu.

Estas credenciales no son las de QCentroid

Tu usuario y contraseña del clúster los emite el equipo de Fujitsu durante el onboarding y son distintos de los que usas para entrar en la plataforma. Los introduces una sola vez, aquí; a partir de ese momento la plataforma los inyecta en tus solvers y nunca los escribes en tu código.

2. Registra tu solver#

Ve a My solvers → Add new solver, y después:

Selecciona uno de los casos de uso existentes.
Selecciona Fujitsu Bizkaia como proveedor de hardware para este solver.
Elige el lenguaje de HPC (python_hpc) en el desplegable de lenguaje de programación. Esto es lo que le indica a la plataforma que construya tu solver con el cliente de HPC y la VPN que este clúster necesita.
Completa el resto de la información y pulsa Add new solver.

3. Implementa tu solver#

Escribe tu qcentroid.py usando el cliente de HPC (mira el solver de ejemplo más abajo) y súbelo a un repositorio Git.

4. Conecta tu repositorio#

Ve a la sección Repositories, pulsa Connect a new repository, selecciona el solver que acabas de crear, rellena el resto de los detalles y pulsa Connect repository.

Ya tienes el solver registrado, conectado al clúster y listo para ejecutarse. Para lanzarlo, consulta Cómo ejecutar un job.

Trabajar con este clúster#

Elegir la partición y los recursos#

El provider ya configura valores por defecto razonables para este clúster, así que un solver que no pase nada envía igualmente un job válido. Sobrescríbelos por job cuando lo necesites:

job_id = client.run_job(
    BATCH_SCRIPT,
    name="my-job",
    partition="da",          # "da" (GPU + Digital Annealer) o "a64" (CPU ARM)
    gres="gpu:1",            # una GPU por nodo; omítelo o usa "" para solo CPU
    memory_per_node=4096,    # MB — mira el aviso de abajo
    time_limit=10,           # minutos
    environment="login",     # para que `module load` funcione
)

Pide siempre la memoria de forma explícita

En la partición da, un job enviado sin una petición de memoria explícita no llega a planificarse nunca: se queda en PENDING para siempre, con el motivo de cola Resources. El valor por defecto del provider te cubre, pero si empiezas a sobrescribir opciones de planificación, asegúrate de que memory_per_node esté entre ellas.

Módulos del clúster#

El software del clúster se carga con module. El cliente Python del Digital Annealer, por ejemplo, viene de su propio módulo:

module load pyfjsvda/1.0.7-py3.11

Dos cosas que recordar para que module funcione dentro de tu job:

Empieza el script con #!/bin/bash -l: la -l lo convierte en un shell de login.
Pasa environment="login" a run_job(), para que el entorno de login del clúster se propague al job.

Pregunta al equipo de Fujitsu qué módulos y versiones hay disponibles: cambian con el tiempo y son específicos de este clúster.

Solver de ejemplo#

Un qcentroid.py completo que ejecuta un job en la partición da:

qcentroid.py

import logging
from qcentroid_solver_runner.hpc import QCentroidHPCClient

logger = logging.getLogger("qcentroid-user-log")   # para que el progreso salga en el panel

# "-l" ejecuta un shell de login, que es lo que hace que `module` esté disponible.
BATCH_SCRIPT = """#!/bin/bash -l
module load pyfjsvda/1.0.7-py3.11

echo "Running on $(hostname)"
python3.11 -c 'print("Hello world from the Fujitsu cluster")'
"""


def run(input_data: dict, solver_params: dict, extra_arguments: dict) -> dict:
    logger.info("Enviando el job al clúster de Fujitsu Bizkaia...")

    with QCentroidHPCClient(logger=logger) as client:
        client.login()

        job_id = client.run_job(
            BATCH_SCRIPT,
            name="my-hpc-job",
            time_limit=10,         # minutos
            environment="login",   # para que `module load` funcione
            # la partición, la memoria y las GPUs toman el valor que configuró el provider
        )
        logger.info("Job %s enviado", job_id)

        # Acota la espera: el clúster es compartido, así que las colas pueden ser largas.
        client.wait_for_completion(job_id, poll_interval=5, queue_timeout=3600, run_timeout=600)

        result = client.get_job_results(job_id)

    logger.info("Job %s terminado: %s (código de salida %s)", result.job_id, result.state, result.exit_code)

    return {
        "job_id": result.job_id,
        "state": result.state,
        "succeeded": result.succeeded,
        "stdout": result.stdout,
        "stderr": result.stderr,
    }

Para resolver un problema QUBO real, sustituye la línea de ejemplo por tu propio script: construye el QUBO a partir de input_data, llama al cliente del Digital Annealer y escribe la solución donde tu solver pueda leerla de vuelta. La referencia completa del cliente —todas las opciones de run_job(), los campos de JobResult y cómo publicar assets— está en Cómo crear un solver de HPC.

Cosas a tener en cuenta#

Los tiempos en cola pueden ser largos. Las GPUs de la partición da se comparten con otros usuarios, así que un job puede pasar un rato encolado antes de arrancar. wait_for_completion() registra el motivo de la cola en cada sondeo; acota la espera con queue_timeout / run_timeout si tu solver no debe esperar indefinidamente.
Un job fallido del clúster no es automáticamente un solver fallido. Tu run() devuelve con normalidad, reportando el estado. Lanza una excepción tú mismo si quieres marcar toda la ejecución como fallida.
Guarda la salida del job. Deja el stdout crudo, informes o gráficas en una carpeta additional_output para publicarlos como assets descargables.
El Digital Annealer lo documenta Fujitsu. La formulación QUBO, los parámetros del DA y la librería cliente están cubiertos por el material que el equipo de Fujitsu proporciona en el onboarding; esta página solo cubre cómo llegar al clúster desde un solver.

Qué sigue#

Cómo crear un solver de HPC

Ejecuta tu solver

Edita o actualiza este solver