docling model evaluation in s390x

### Question
I am evaluating the Docling model to compare its performance on CPU and NNPA. However, I noticed that when running on the CPU, the model takes around 15–20 minutes just to generate the output. Is this expected behavior for the model?

I have included the notebook with the code below for reference.

```
# Granite Docling Benchmark (Image-only, with token)
# =========================================================

import time
import torch
from transformers import AutoModelForVision2Seq, AutoProcessor
from PIL import Image
from IPython.display import display, HTML
import warnings
warnings.filterwarnings("ignore")
from transformers import logging
logging.set_verbosity_error()

# -------------------------------
# Model and documents setup
# -------------------------------
model_name = "ibm-granite/granite-docling-258M"

documents = [
{
"file_path": "/home/ibm-user/image-2.jpg", # update path if needed
"extra_info": {"doc_id": "img1", "source": "manual"}
}
]

# Must include placeholder
question = "Here is a document: \nQuestion: What is the Net income in 2008?"

devices_to_test = ["cpu", "nnpa"]
results = []

# -------------------------------
# Run inference
# -------------------------------
for device_type in devices_to_test:
try:
if device_type == "nnpa":
import torch_nnpa
device = torch_nnpa.device()
device_label = "NNPA"
else:
device = torch.device("cpu")
device_label = "CPU"

display(HTML(f"

Running on: {device_label}

"))

# Load model + processor
start_pipe = time.time()
model = AutoModelForVision2Seq.from_pretrained(
model_name,
trust_remote_code=True
).to(device)

processor = AutoProcessor.from_pretrained(model_name, trust_remote_code=True)
pipeline_loading_time = time.time() - start_pipe

for doc in documents:
file_path = doc["file_path"]

# Load image
img = Image.open(file_path).convert("RGB")
img = img.resize((224, 224))

# Inference
start = time.time()
inputs = processor(
text=[question], # includes
images=[img], # same length as tokens
return_tensors="pt"
).to(device)
#outputs = model.generate(**inputs, max_new_tokens=4, do_sample=False, num_beams=1)
outputs = model.generate(**inputs, max_new_tokens=8)
avg_inference_time = time.time() - start

response = processor.batch_decode(outputs, skip_special_tokens=True)[0]
tokens_generated = len(response.split())
tokens_per_sec = tokens_generated / avg_inference_time if avg_inference_time > 0 else 0

results.append({
"device": device_label,
"doc_id": doc["extra_info"].get("doc_id", ""),
"pipeline_loading_time": pipeline_loading_time,
"inference_time": avg_inference_time,
"tokens_generated": tokens_generated,
"tokens_per_sec": tokens_per_sec,
"response": response
})

except Exception as ex:
print(f" Error on {device_label}: {ex}")

# -------------------------------
# Styled CPU vs NNPA Comparison
# -------------------------------
metrics = ["pipeline_loading_time", "inference_time", "tokens_generated", "tokens_per_sec"]
labels = ["Pipeline Load Time (s)", "Avg Inference Time (s)", "Tokens Generated", "Tokens per second"]

if len(results) > 1:
cpu_result = next((r for r in results if r["device"] == "CPU"), {})
nnpa_result = next((r for r in results if r["device"] == "NNPA"), {})

comparison_html = """

"""

display(HTML(comparison_html))
else:
display(HTML("

Not enough results to compare CPU and NNPA.

"))
```

Reproduce the inline Granite Docling benchmark on s390x, comparing the CPU and NNPA paths with the stated image and generation settings. Record model-loading and inference times, then determine whether the 15–20 minute CPU runtime is expected and document the comparison outcome.

Written by the indexing model from the issue text.