Migrate x86 applications to AWS Graviton using Kiro and the Arm MCP Server

{
"mcpServers": {
"arm-mcp": {
"command": "docker",
"args": [
"run",
"--rm",
"-i",
"--pull=always",
"-v", "/home/ubuntu/arm-migration:/workspace",
"armlimited/arm-mcp"
],
"timeout": 60000
}
}
}

FROM centos:6

# CentOS 6 reached EOL, need to use vault mirrors
RUN sed -i 's|^mirrorlist=|#mirrorlist=|g' /etc/yum.repos.d/CentOS-Base.repo && \
sed -i 's|^#baseurl=http://mirror.centos.org|baseurl=http://vault.centos.org|g' /etc/yum.repos.d/CentOS-Base.repo

# Install build tools
RUN yum install -y gcc gcc-c++ make && yum clean all

WORKDIR /app
COPY *.cpp *.h ./

# Build with x86 AVX2 optimizations
RUN g++ -O2 -mavx2 -o benchmark main.cpp matrix_operations.cpp -std=c++11

CMD ["./benchmark"]

#ifndef MATRIX_OPERATIONS_H
#define MATRIX_OPERATIONS_H

#include <vector>
#include <cstddef>

class Matrix {
private:
std::vector<std::vector<double>> data;
size_t rows;
size_t cols;

public:
Matrix(size_t r, size_t c);
void randomize();
Matrix multiply(const Matrix& other) const;
double sum() const;

size_t getRows() const { return rows; }
size_t getCols() const { return cols; }
};

void benchmark_matrix_ops();

#endif

#include "matrix_operations.h"
#include <iostream>
#include <random>
#include <chrono>
#include <stdexcept>
#include <immintrin.h> // AVX2 intrinsics

Matrix::Matrix(size_t r, size_t c) : rows(r), cols(c) {
data.resize(rows, std::vector<double>(cols, 0.0));
}

void Matrix::randomize() {
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_real_distribution<> dis(0.0, 10.0);

for (size_t i = 0; i < rows; i++) {
for (size_t j = 0; j < cols; j++) {
data[i][j] = dis(gen);
}
}
}

Matrix Matrix::multiply(const Matrix& other) const {
if (cols != other.rows) {
throw std::runtime_error("Invalid matrix dimensions for multiplication");
}

Matrix result(rows, other.cols);

// x86-64 optimized using AVX2 for double-precision
for (size_t i = 0; i < rows; i++) {
for (size_t j = 0; j < other.cols; j++) {
__m256d sum_vec = _mm256_setzero_pd();
size_t k = 0;

// Process 4 elements at a time with AVX2
for (; k + 3 < cols; k += 4) {
__m256d a_vec = _mm256_loadu_pd(&data[i][k]);
__m256d b_vec = _mm256_set_pd(
other.data[k+3][j],
other.data[k+2][j],
other.data[k+1][j],
other.data[k][j]
);
sum_vec = _mm256_add_pd(sum_vec, _mm256_mul_pd(a_vec, b_vec));
}

// Horizontal add using AVX
__m128d sum_high = _mm256_extractf128_pd(sum_vec, 1);
__m128d sum_low = _mm256_castpd256_pd128(sum_vec);
__m128d sum_128 = _mm_add_pd(sum_low, sum_high);

double sum_arr[2];
_mm_storeu_pd(sum_arr, sum_128);
double sum = sum_arr[0] + sum_arr[1];

// Handle remaining elements
for (; k < cols; k++) {
sum += data[i][k] * other.data[k][j];
}

result.data[i][j] = sum;
}
}

return result;
}

double Matrix::sum() const {
double total = 0.0;
for (size_t i = 0; i < rows; i++) {
for (size_t j = 0; j < cols; j++) {
total += data[i][j];
}
}
return total;
}

void benchmark_matrix_ops() {
std::cout << "\n=== Matrix Multiplication Benchmark ===" << std::endl;

const size_t size = 200;
Matrix a(size, size);
Matrix b(size, size);

a.randomize();
b.randomize();

auto start = std::chrono::high_resolution_clock::now();
Matrix c = a.multiply(b);
auto end = std::chrono::high_resolution_clock::now();

auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);

std::cout << "Matrix size: " << size << "x" << size << std::endl;
std::cout << "Time: " << duration.count() << " ms" << std::endl;
std::cout << "Result sum: " << c.sum() << std::endl;
}

#include "matrix_operations.h"
#include <iostream>

int main() {
std::cout << "Matrix Operations Benchmark" << std::endl;
std::cout << "===========================" << std::endl;

benchmark_matrix_ops();

return 0;
}

FROM centos:6

# CentOS 6 reached EOL, need to use vault mirrors
RUN sed -i 's|^mirrorlist=|#mirrorlist=|g' /etc/yum.repos.d/CentOS-Base.repo && \
sed -i 's|^#baseurl=http://mirror.centos.org|baseurl=http://vault.centos.org|g' /etc/yum.repos.d/CentOS-Base.repo

# Install build tools
RUN yum install -y gcc gcc-c++ make && yum clean all

WORKDIR /app
COPY *.cpp *.h ./

# Build with x86 AVX2 optimizations
RUN g++ -O2 -mavx2 -o benchmark main.cpp matrix_operations.cpp -std=c++11

CMD ["./benchmark"]

The only Arm-incompatible code was the AVX2 SIMD matrix multiply in
matrix_operations.cpp. The migrate-ease scan confirmed exactly 9 issues
(1 incompatible header + 8 AVX2 intrinsics), all in that one function.

matrix_operations.cpp — replaced the x86-only SIMD path with a portable
preprocessor-guarded implementation:
- __aarch64__ → Arm NEON (arm_neon.h), the path Graviton uses
- __AVX2__ → original AVX2 (kept so x86 builds still work)
- otherwise → scalar fallback

Key translation: NEON registers are 128-bit (2 doubles) vs AVX2's 256-bit
(4 doubles), so the loop stride dropped from 4 to 2, and the x86
horizontal-reduction became a single vaddvq_f64.