cephi/ampere_research
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

More data

Browse Source
This commit is contained in:
cephi 2024-12-17 19:30:42 -05:00
parent a9a2b170fc
commit 0def30ded2
923 changed files with 47937 additions and 16658 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_100000_0.0001.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Altra", "CORES": 16, "ITERATIONS": 1755, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [100000, 100000], "MATRIX_ROWS": 100000, "MATRIX_SIZE": 10000000000, "MATRIX_NNZ": 1000000, "MATRIX_DENSITY": 0.0001, "TIME_S": 10.253487825393677, "TIME_S_1KI": 5.842443205352523, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 467.2838370990753, "W": 31.934101368331916, "J_1KI": 266.2585966376497, "W_1KI": 18.196069155744684, "W_D": 16.879101368331916, "J_D": 246.98773149132728, "W_D_1KI": 9.617721577397104, "J_D_1KI": 5.480183234984104}

65
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_100000_0.0001.output Normal file
View File

@ -0,0 +1,65 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 1000 -ss 100000 -sd 0.0001 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [100000, 100000], "MATRIX_ROWS": 100000, "MATRIX_SIZE": 10000000000, "MATRIX_NNZ": 1000000, "MATRIX_DENSITY": 0.0001, "TIME_S": 5.980836629867554}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 11, 22, ..., 999980,
999989, 1000000]),
col_indices=tensor([ 6100, 13265, 27848, ..., 84407, 91090, 94721]),
values=tensor([0.4400, 0.3445, 0.5606, ..., 0.5861, 0.7102, 0.2795]),
size=(100000, 100000), nnz=1000000, layout=torch.sparse_csr)
tensor([0.6757, 0.5029, 0.1898, ..., 0.2612, 0.6123, 0.0844])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([100000, 100000])
Rows: 100000
Size: 10000000000
NNZ: 1000000
Density: 0.0001
Time: 5.980836629867554 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 1755 -ss 100000 -sd 0.0001 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [100000, 100000], "MATRIX_ROWS": 100000, "MATRIX_SIZE": 10000000000, "MATRIX_NNZ": 1000000, "MATRIX_DENSITY": 0.0001, "TIME_S": 10.253487825393677}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 5, 18, ..., 999983,
999994, 1000000]),
col_indices=tensor([22305, 51740, 53616, ..., 72974, 76091, 88145]),
values=tensor([0.7756, 0.0657, 0.7358, ..., 0.9841, 0.0331, 0.5251]),
size=(100000, 100000), nnz=1000000, layout=torch.sparse_csr)
tensor([0.4750, 0.6821, 0.2847, ..., 0.3502, 0.4038, 0.5877])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([100000, 100000])
Rows: 100000
Size: 10000000000
NNZ: 1000000
Density: 0.0001
Time: 10.253487825393677 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 5, 18, ..., 999983,
999994, 1000000]),
col_indices=tensor([22305, 51740, 53616, ..., 72974, 76091, 88145]),
values=tensor([0.7756, 0.0657, 0.7358, ..., 0.9841, 0.0331, 0.5251]),
size=(100000, 100000), nnz=1000000, layout=torch.sparse_csr)
tensor([0.4750, 0.6821, 0.2847, ..., 0.3502, 0.4038, 0.5877])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([100000, 100000])
Rows: 100000
Size: 10000000000
NNZ: 1000000
Density: 0.0001
Time: 10.253487825393677 seconds
[16.48, 16.16, 16.52, 16.48, 16.48, 16.48, 16.72, 16.72, 16.84, 17.12]
[17.08, 17.16, 17.96, 19.72, 22.2, 27.16, 34.52, 39.08, 43.72, 45.96, 46.32, 46.32, 46.2, 46.28]
14.632753610610962
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 1755, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [100000, 100000], 'MATRIX_ROWS': 100000, 'MATRIX_SIZE': 10000000000, 'MATRIX_NNZ': 1000000, 'MATRIX_DENSITY': 0.0001, 'TIME_S': 10.253487825393677, 'TIME_S_1KI': 5.842443205352523, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 467.2838370990753, 'W': 31.934101368331916}
[16.48, 16.16, 16.52, 16.48, 16.48, 16.48, 16.72, 16.72, 16.84, 17.12, 16.72, 16.8, 16.96, 17.0, 17.04, 16.88, 16.8, 16.88, 16.76, 16.84]
301.1
15.055000000000001
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 1755, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [100000, 100000], 'MATRIX_ROWS': 100000, 'MATRIX_SIZE': 10000000000, 'MATRIX_NNZ': 1000000, 'MATRIX_DENSITY': 0.0001, 'TIME_S': 10.253487825393677, 'TIME_S_1KI': 5.842443205352523, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 467.2838370990753, 'W': 31.934101368331916, 'J_1KI': 266.2585966376497, 'W_1KI': 18.196069155744684, 'W_D': 16.879101368331916, 'J_D': 246.98773149132728, 'W_D_1KI': 9.617721577397104, 'J_D_1KI': 5.480183234984104}

1
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_100000_0.001.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Altra", "CORES": 16, "ITERATIONS": 1000, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [100000, 100000], "MATRIX_ROWS": 100000, "MATRIX_SIZE": 10000000000, "MATRIX_NNZ": 10000000, "MATRIX_DENSITY": 0.001, "TIME_S": 57.53653693199158, "TIME_S_1KI": 57.53653693199158, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 2684.526071929932, "W": 41.311972802980506, "J_1KI": 2684.526071929932, "W_1KI": 41.311972802980506, "W_D": 26.003972802980506, "J_D": 1689.784782156945, "W_D_1KI": 26.003972802980506, "J_D_1KI": 26.003972802980506}

45
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_100000_0.001.output Normal file
View File

@ -0,0 +1,45 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 1000 -ss 100000 -sd 0.001 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [100000, 100000], "MATRIX_ROWS": 100000, "MATRIX_SIZE": 10000000000, "MATRIX_NNZ": 10000000, "MATRIX_DENSITY": 0.001, "TIME_S": 57.53653693199158}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 92, 190, ..., 9999802,
9999900, 10000000]),
col_indices=tensor([ 766, 3080, 3658, ..., 98863, 99077, 99078]),
values=tensor([0.0329, 0.7493, 0.2063, ..., 0.1215, 0.3807, 0.7288]),
size=(100000, 100000), nnz=10000000, layout=torch.sparse_csr)
tensor([0.3516, 0.3347, 0.9443, ..., 0.8917, 0.2195, 0.8723])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([100000, 100000])
Rows: 100000
Size: 10000000000
NNZ: 10000000
Density: 0.001
Time: 57.53653693199158 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 92, 190, ..., 9999802,
9999900, 10000000]),
col_indices=tensor([ 766, 3080, 3658, ..., 98863, 99077, 99078]),
values=tensor([0.0329, 0.7493, 0.2063, ..., 0.1215, 0.3807, 0.7288]),
size=(100000, 100000), nnz=10000000, layout=torch.sparse_csr)
tensor([0.3516, 0.3347, 0.9443, ..., 0.8917, 0.2195, 0.8723])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([100000, 100000])
Rows: 100000
Size: 10000000000
NNZ: 10000000
Density: 0.001
Time: 57.53653693199158 seconds
[17.2, 17.2, 16.8, 16.8, 17.0, 16.88, 16.88, 17.0, 17.0, 16.6]
[16.88, 16.84, 17.36, 19.48, 20.16, 21.92, 24.16, 24.88, 27.6, 33.04, 37.56, 43.08, 47.0, 46.96, 47.68, 47.76, 47.76, 47.48, 47.4, 46.92, 47.28, 47.04, 47.56, 48.36, 48.0, 47.68, 47.44, 46.16, 45.68, 46.04, 46.32, 47.44, 47.76, 47.84, 47.64, 47.36, 47.08, 46.96, 46.96, 47.16, 46.68, 46.24, 46.2, 46.44, 46.56, 47.0, 48.08, 48.0, 48.12, 48.44, 48.48, 48.2, 47.64, 47.32, 47.2, 47.2, 47.56, 47.52, 47.68, 47.8, 47.8, 48.0]
64.98179316520691
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 1000, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [100000, 100000], 'MATRIX_ROWS': 100000, 'MATRIX_SIZE': 10000000000, 'MATRIX_NNZ': 10000000, 'MATRIX_DENSITY': 0.001, 'TIME_S': 57.53653693199158, 'TIME_S_1KI': 57.53653693199158, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 2684.526071929932, 'W': 41.311972802980506}
[17.2, 17.2, 16.8, 16.8, 17.0, 16.88, 16.88, 17.0, 17.0, 16.6, 17.12, 17.12, 17.04, 17.0, 17.0, 16.96, 16.88, 16.92, 17.32, 17.8]
306.16
15.308000000000002
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 1000, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [100000, 100000], 'MATRIX_ROWS': 100000, 'MATRIX_SIZE': 10000000000, 'MATRIX_NNZ': 10000000, 'MATRIX_DENSITY': 0.001, 'TIME_S': 57.53653693199158, 'TIME_S_1KI': 57.53653693199158, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 2684.526071929932, 'W': 41.311972802980506, 'J_1KI': 2684.526071929932, 'W_1KI': 41.311972802980506, 'W_D': 26.003972802980506, 'J_D': 1689.784782156945, 'W_D_1KI': 26.003972802980506, 'J_D_1KI': 26.003972802980506}

1
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_100000_1e-05.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Altra", "CORES": 16, "ITERATIONS": 11928, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [100000, 100000], "MATRIX_ROWS": 100000, "MATRIX_SIZE": 10000000000, "MATRIX_NNZ": 100000, "MATRIX_DENSITY": 1e-05, "TIME_S": 10.779903888702393, "TIME_S_1KI": 0.9037478109240772, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 428.71311614990236, "W": 29.263266081724595, "J_1KI": 35.94174347333186, "W_1KI": 2.4533254595677896, "W_D": 14.015266081724594, "J_D": 205.326650100708, "W_D_1KI": 1.1749887727803985, "J_D_1KI": 0.09850677169520444}

65
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_100000_1e-05.output Normal file
View File

@ -0,0 +1,65 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 1000 -ss 100000 -sd 1e-05 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [100000, 100000], "MATRIX_ROWS": 100000, "MATRIX_SIZE": 10000000000, "MATRIX_NNZ": 100000, "MATRIX_DENSITY": 1e-05, "TIME_S": 0.8802759647369385}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 1, 1, ..., 99998, 99998,
100000]),
col_indices=tensor([50190, 32056, 73796, ..., 55938, 31334, 37461]),
values=tensor([0.0722, 0.7116, 0.8310, ..., 0.7930, 0.8115, 0.4149]),
size=(100000, 100000), nnz=100000, layout=torch.sparse_csr)
tensor([0.5168, 0.3496, 0.0063, ..., 0.9888, 0.0960, 0.5324])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([100000, 100000])
Rows: 100000
Size: 10000000000
NNZ: 100000
Density: 1e-05
Time: 0.8802759647369385 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 11928 -ss 100000 -sd 1e-05 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [100000, 100000], "MATRIX_ROWS": 100000, "MATRIX_SIZE": 10000000000, "MATRIX_NNZ": 100000, "MATRIX_DENSITY": 1e-05, "TIME_S": 10.779903888702393}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 2, 3, ..., 99995, 99996,
100000]),
col_indices=tensor([15079, 22431, 71484, ..., 38240, 57604, 63673]),
values=tensor([0.6856, 0.2309, 0.0261, ..., 0.6883, 0.7108, 0.1151]),
size=(100000, 100000), nnz=100000, layout=torch.sparse_csr)
tensor([0.6131, 0.6051, 0.4027, ..., 0.3545, 0.9505, 0.4978])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([100000, 100000])
Rows: 100000
Size: 10000000000
NNZ: 100000
Density: 1e-05
Time: 10.779903888702393 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 2, 3, ..., 99995, 99996,
100000]),
col_indices=tensor([15079, 22431, 71484, ..., 38240, 57604, 63673]),
values=tensor([0.6856, 0.2309, 0.0261, ..., 0.6883, 0.7108, 0.1151]),
size=(100000, 100000), nnz=100000, layout=torch.sparse_csr)
tensor([0.6131, 0.6051, 0.4027, ..., 0.3545, 0.9505, 0.4978])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([100000, 100000])
Rows: 100000
Size: 10000000000
NNZ: 100000
Density: 1e-05
Time: 10.779903888702393 seconds
[17.04, 17.24, 17.0, 17.0, 16.8, 16.64, 16.64, 16.68, 16.92, 16.84]
[16.64, 16.52, 16.72, 17.8, 20.04, 25.4, 30.88, 34.96, 39.88, 41.96, 42.28, 42.44, 42.56, 42.56]
14.650214195251465
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 11928, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [100000, 100000], 'MATRIX_ROWS': 100000, 'MATRIX_SIZE': 10000000000, 'MATRIX_NNZ': 100000, 'MATRIX_DENSITY': 1e-05, 'TIME_S': 10.779903888702393, 'TIME_S_1KI': 0.9037478109240772, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 428.71311614990236, 'W': 29.263266081724595}
[17.04, 17.24, 17.0, 17.0, 16.8, 16.64, 16.64, 16.68, 16.92, 16.84, 16.84, 16.84, 17.0, 17.0, 16.92, 17.0, 17.16, 17.0, 17.16, 17.2]
304.96000000000004
15.248000000000001
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 11928, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [100000, 100000], 'MATRIX_ROWS': 100000, 'MATRIX_SIZE': 10000000000, 'MATRIX_NNZ': 100000, 'MATRIX_DENSITY': 1e-05, 'TIME_S': 10.779903888702393, 'TIME_S_1KI': 0.9037478109240772, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 428.71311614990236, 'W': 29.263266081724595, 'J_1KI': 35.94174347333186, 'W_1KI': 2.4533254595677896, 'W_D': 14.015266081724594, 'J_D': 205.326650100708, 'W_D_1KI': 1.1749887727803985, 'J_D_1KI': 0.09850677169520444}

1
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_100000_5e-05.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Altra", "CORES": 16, "ITERATIONS": 3268, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [100000, 100000], "MATRIX_ROWS": 100000, "MATRIX_SIZE": 10000000000, "MATRIX_NNZ": 500000, "MATRIX_DENSITY": 5e-05, "TIME_S": 10.551287174224854, "TIME_S_1KI": 3.2286680459684374, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 514.9588033294677, "W": 35.14704993762719, "J_1KI": 157.57613320975145, "W_1KI": 10.754911241623986, "W_D": 16.333049937627187, "J_D": 239.30451817512508, "W_D_1KI": 4.997873297927536, "J_D_1KI": 1.5293369944698703}

65
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_100000_5e-05.output Normal file
View File

@ -0,0 +1,65 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 1000 -ss 100000 -sd 5e-05 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [100000, 100000], "MATRIX_ROWS": 100000, "MATRIX_SIZE": 10000000000, "MATRIX_NNZ": 500000, "MATRIX_DENSITY": 5e-05, "TIME_S": 3.21274733543396}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 5, 10, ..., 499991, 499996,
500000]),
col_indices=tensor([ 6819, 16249, 65142, ..., 35181, 90238, 95591]),
values=tensor([0.9907, 0.7784, 0.8470, ..., 0.0401, 0.4552, 0.5172]),
size=(100000, 100000), nnz=500000, layout=torch.sparse_csr)
tensor([0.1211, 0.3699, 0.8120, ..., 0.3387, 0.3308, 0.0427])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([100000, 100000])
Rows: 100000
Size: 10000000000
NNZ: 500000
Density: 5e-05
Time: 3.21274733543396 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 3268 -ss 100000 -sd 5e-05 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [100000, 100000], "MATRIX_ROWS": 100000, "MATRIX_SIZE": 10000000000, "MATRIX_NNZ": 500000, "MATRIX_DENSITY": 5e-05, "TIME_S": 10.551287174224854}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 6, 10, ..., 499988, 499994,
500000]),
col_indices=tensor([ 4698, 29712, 45324, ..., 47109, 54294, 79244]),
values=tensor([0.0467, 0.0395, 0.2018, ..., 0.4601, 0.1623, 0.8954]),
size=(100000, 100000), nnz=500000, layout=torch.sparse_csr)
tensor([0.1366, 0.5632, 0.5706, ..., 0.2593, 0.9938, 0.0917])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([100000, 100000])
Rows: 100000
Size: 10000000000
NNZ: 500000
Density: 5e-05
Time: 10.551287174224854 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 6, 10, ..., 499988, 499994,
500000]),
col_indices=tensor([ 4698, 29712, 45324, ..., 47109, 54294, 79244]),
values=tensor([0.0467, 0.0395, 0.2018, ..., 0.4601, 0.1623, 0.8954]),
size=(100000, 100000), nnz=500000, layout=torch.sparse_csr)
tensor([0.1366, 0.5632, 0.5706, ..., 0.2593, 0.9938, 0.0917])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([100000, 100000])
Rows: 100000
Size: 10000000000
NNZ: 500000
Density: 5e-05
Time: 10.551287174224854 seconds
[20.52, 20.48, 20.56, 20.6, 20.6, 20.88, 21.08, 21.04, 21.04, 20.92]
[20.68, 20.64, 20.84, 22.28, 23.8, 29.96, 35.72, 42.6, 47.2, 50.88, 50.56, 50.96, 50.68, 50.8]
14.651551246643066
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 3268, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [100000, 100000], 'MATRIX_ROWS': 100000, 'MATRIX_SIZE': 10000000000, 'MATRIX_NNZ': 500000, 'MATRIX_DENSITY': 5e-05, 'TIME_S': 10.551287174224854, 'TIME_S_1KI': 3.2286680459684374, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 514.9588033294677, 'W': 35.14704993762719}
[20.52, 20.48, 20.56, 20.6, 20.6, 20.88, 21.08, 21.04, 21.04, 20.92, 20.72, 21.08, 21.16, 21.16, 21.24, 21.28, 21.16, 20.88, 20.68, 20.56]
376.28
18.814
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 3268, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [100000, 100000], 'MATRIX_ROWS': 100000, 'MATRIX_SIZE': 10000000000, 'MATRIX_NNZ': 500000, 'MATRIX_DENSITY': 5e-05, 'TIME_S': 10.551287174224854, 'TIME_S_1KI': 3.2286680459684374, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 514.9588033294677, 'W': 35.14704993762719, 'J_1KI': 157.57613320975145, 'W_1KI': 10.754911241623986, 'W_D': 16.333049937627187, 'J_D': 239.30451817512508, 'W_D_1KI': 4.997873297927536, 'J_D_1KI': 1.5293369944698703}

1
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_10000_0.0001.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Altra", "CORES": 16, "ITERATIONS": 32824, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 10000, "MATRIX_DENSITY": 0.0001, "TIME_S": 10.612937211990356, "TIME_S_1KI": 0.3233285770165232, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 275.6484677696228, "W": 19.42651909848855, "J_1KI": 8.397771989081855, "W_1KI": 0.5918388709020398, "W_D": 4.498519098488551, "J_D": 63.83078154373167, "W_D_1KI": 0.13704969225227123, "J_D_1KI": 0.004175289186335341}

81
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_10000_0.0001.output Normal file
View File

@ -0,0 +1,81 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 1000 -ss 10000 -sd 0.0001 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 10000, "MATRIX_DENSITY": 0.0001, "TIME_S": 0.3622722625732422}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 2, 4, ..., 9997, 10000, 10000]),
col_indices=tensor([2430, 5032, 1477, ..., 758, 3153, 4599]),
values=tensor([0.8038, 0.4543, 0.3152, ..., 0.6785, 0.4391, 0.0535]),
size=(10000, 10000), nnz=10000, layout=torch.sparse_csr)
tensor([0.9594, 0.1900, 0.3074, ..., 0.8950, 0.9459, 0.6732])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 10000
Density: 0.0001
Time: 0.3622722625732422 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 28983 -ss 10000 -sd 0.0001 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 10000, "MATRIX_DENSITY": 0.0001, "TIME_S": 9.27123761177063}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 1, 2, ..., 10000, 10000, 10000]),
col_indices=tensor([1532, 2817, 884, ..., 2356, 6175, 1948]),
values=tensor([0.3809, 0.2852, 0.7235, ..., 0.6592, 0.2563, 0.7726]),
size=(10000, 10000), nnz=10000, layout=torch.sparse_csr)
tensor([0.6771, 0.1497, 0.5070, ..., 0.8092, 0.9643, 0.7887])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 10000
Density: 0.0001
Time: 9.27123761177063 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 32824 -ss 10000 -sd 0.0001 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 10000, "MATRIX_DENSITY": 0.0001, "TIME_S": 10.612937211990356}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 1, 1, ..., 9999, 9999, 10000]),
col_indices=tensor([3350, 4490, 6839, ..., 6784, 8596, 8737]),
values=tensor([0.3991, 0.5600, 0.2439, ..., 0.8859, 0.9485, 0.6345]),
size=(10000, 10000), nnz=10000, layout=torch.sparse_csr)
tensor([0.2861, 0.2741, 0.4038, ..., 0.8389, 0.9796, 0.7969])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 10000
Density: 0.0001
Time: 10.612937211990356 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 1, 1, ..., 9999, 9999, 10000]),
col_indices=tensor([3350, 4490, 6839, ..., 6784, 8596, 8737]),
values=tensor([0.3991, 0.5600, 0.2439, ..., 0.8859, 0.9485, 0.6345]),
size=(10000, 10000), nnz=10000, layout=torch.sparse_csr)
tensor([0.2861, 0.2741, 0.4038, ..., 0.8389, 0.9796, 0.7969])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 10000
Density: 0.0001
Time: 10.612937211990356 seconds
[16.64, 16.84, 16.96, 16.88, 16.84, 16.72, 17.08, 16.96, 16.92, 16.92]
[17.08, 16.72, 16.76, 21.08, 22.52, 24.76, 25.6, 23.4, 22.04, 20.32, 20.04, 20.0, 20.0, 20.12]
14.189287662506104
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 32824, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [10000, 10000], 'MATRIX_ROWS': 10000, 'MATRIX_SIZE': 100000000, 'MATRIX_NNZ': 10000, 'MATRIX_DENSITY': 0.0001, 'TIME_S': 10.612937211990356, 'TIME_S_1KI': 0.3233285770165232, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 275.6484677696228, 'W': 19.42651909848855}
[16.64, 16.84, 16.96, 16.88, 16.84, 16.72, 17.08, 16.96, 16.92, 16.92, 16.36, 16.04, 15.84, 15.92, 16.12, 16.28, 16.36, 16.68, 16.72, 16.88]
298.56
14.928
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 32824, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [10000, 10000], 'MATRIX_ROWS': 10000, 'MATRIX_SIZE': 100000000, 'MATRIX_NNZ': 10000, 'MATRIX_DENSITY': 0.0001, 'TIME_S': 10.612937211990356, 'TIME_S_1KI': 0.3233285770165232, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 275.6484677696228, 'W': 19.42651909848855, 'J_1KI': 8.397771989081855, 'W_1KI': 0.5918388709020398, 'W_D': 4.498519098488551, 'J_D': 63.83078154373167, 'W_D_1KI': 0.13704969225227123, 'J_D_1KI': 0.004175289186335341}

1
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_10000_0.001.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Altra", "CORES": 16, "ITERATIONS": 4599, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 100000, "MATRIX_DENSITY": 0.001, "TIME_S": 10.21649432182312, "TIME_S_1KI": 2.2214599525599303, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 276.3690100479126, "W": 19.391688491473598, "J_1KI": 60.09328333287945, "W_1KI": 4.2165010853389, "W_D": 4.4646884914736, "J_D": 63.630433167457575, "W_D_1KI": 0.9707954971675582, "J_D_1KI": 0.21108838816428752}

65
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_10000_0.001.output Normal file
View File

@ -0,0 +1,65 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 1000 -ss 10000 -sd 0.001 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 100000, "MATRIX_DENSITY": 0.001, "TIME_S": 2.282747268676758}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 15, 26, ..., 99983, 99992,
100000]),
col_indices=tensor([ 746, 1254, 2691, ..., 5665, 9904, 9986]),
values=tensor([0.7024, 0.2927, 0.8116, ..., 0.2675, 0.5863, 0.1724]),
size=(10000, 10000), nnz=100000, layout=torch.sparse_csr)
tensor([0.2042, 0.3555, 0.3767, ..., 0.6038, 0.4952, 0.0036])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 100000
Density: 0.001
Time: 2.282747268676758 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 4599 -ss 10000 -sd 0.001 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 100000, "MATRIX_DENSITY": 0.001, "TIME_S": 10.21649432182312}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 6, 18, ..., 99975, 99989,
100000]),
col_indices=tensor([5193, 5456, 6247, ..., 5100, 5946, 8330]),
values=tensor([0.7086, 0.0012, 0.4180, ..., 0.5448, 0.8405, 0.8114]),
size=(10000, 10000), nnz=100000, layout=torch.sparse_csr)
tensor([0.0495, 0.0946, 0.7654, ..., 0.8976, 0.3544, 0.9283])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 100000
Density: 0.001
Time: 10.21649432182312 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 6, 18, ..., 99975, 99989,
100000]),
col_indices=tensor([5193, 5456, 6247, ..., 5100, 5946, 8330]),
values=tensor([0.7086, 0.0012, 0.4180, ..., 0.5448, 0.8405, 0.8114]),
size=(10000, 10000), nnz=100000, layout=torch.sparse_csr)
tensor([0.0495, 0.0946, 0.7654, ..., 0.8976, 0.3544, 0.9283])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 100000
Density: 0.001
Time: 10.21649432182312 seconds
[16.44, 16.28, 16.32, 16.56, 16.56, 16.6, 16.76, 16.76, 16.72, 16.68]
[16.52, 16.48, 16.6, 20.0, 22.08, 24.8, 25.56, 23.6, 23.04, 20.28, 20.28, 20.04, 20.16, 20.2]
14.251931190490723
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 4599, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [10000, 10000], 'MATRIX_ROWS': 10000, 'MATRIX_SIZE': 100000000, 'MATRIX_NNZ': 100000, 'MATRIX_DENSITY': 0.001, 'TIME_S': 10.21649432182312, 'TIME_S_1KI': 2.2214599525599303, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 276.3690100479126, 'W': 19.391688491473598}
[16.44, 16.28, 16.32, 16.56, 16.56, 16.6, 16.76, 16.76, 16.72, 16.68, 16.4, 16.48, 16.68, 16.36, 16.44, 16.64, 16.64, 16.8, 16.8, 16.76]
298.53999999999996
14.926999999999998
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 4599, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [10000, 10000], 'MATRIX_ROWS': 10000, 'MATRIX_SIZE': 100000000, 'MATRIX_NNZ': 100000, 'MATRIX_DENSITY': 0.001, 'TIME_S': 10.21649432182312, 'TIME_S_1KI': 2.2214599525599303, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 276.3690100479126, 'W': 19.391688491473598, 'J_1KI': 60.09328333287945, 'W_1KI': 4.2165010853389, 'W_D': 4.4646884914736, 'J_D': 63.630433167457575, 'W_D_1KI': 0.9707954971675582, 'J_D_1KI': 0.21108838816428752}

1
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_10000_0.01.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Altra", "CORES": 16, "ITERATIONS": 1000, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 1000000, "MATRIX_DENSITY": 0.01, "TIME_S": 21.366477489471436, "TIME_S_1KI": 21.366477489471436, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 489.4337509441374, "W": 19.31282985940674, "J_1KI": 489.4337509441374, "W_1KI": 19.31282985940674, "W_D": 4.539829859406739, "J_D": 115.05025275492645, "W_D_1KI": 4.539829859406739, "J_D_1KI": 4.539829859406739}

45
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_10000_0.01.output Normal file
View File

@ -0,0 +1,45 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 1000 -ss 10000 -sd 0.01 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 1000000, "MATRIX_DENSITY": 0.01, "TIME_S": 21.366477489471436}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 93, 201, ..., 999801,
999899, 1000000]),
col_indices=tensor([ 106, 113, 159, ..., 9934, 9937, 9966]),
values=tensor([0.1214, 0.4144, 0.1866, ..., 0.5194, 0.7412, 0.0565]),
size=(10000, 10000), nnz=1000000, layout=torch.sparse_csr)
tensor([0.4749, 0.5757, 0.5717, ..., 0.5026, 0.5396, 0.1085])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 1000000
Density: 0.01
Time: 21.366477489471436 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 93, 201, ..., 999801,
999899, 1000000]),
col_indices=tensor([ 106, 113, 159, ..., 9934, 9937, 9966]),
values=tensor([0.1214, 0.4144, 0.1866, ..., 0.5194, 0.7412, 0.0565]),
size=(10000, 10000), nnz=1000000, layout=torch.sparse_csr)
tensor([0.4749, 0.5757, 0.5717, ..., 0.5026, 0.5396, 0.1085])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 1000000
Density: 0.01
Time: 21.366477489471436 seconds
[16.76, 16.8, 16.72, 16.6, 16.36, 16.12, 16.0, 16.04, 16.28, 16.36]
[16.48, 16.48, 16.36, 17.76, 18.4, 22.04, 22.96, 22.96, 22.68, 21.88, 20.28, 20.28, 20.36, 20.0, 20.0, 19.8, 19.72, 19.84, 19.96, 20.12, 20.32, 20.36, 20.56, 20.72, 20.6]
25.34241509437561
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 1000, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [10000, 10000], 'MATRIX_ROWS': 10000, 'MATRIX_SIZE': 100000000, 'MATRIX_NNZ': 1000000, 'MATRIX_DENSITY': 0.01, 'TIME_S': 21.366477489471436, 'TIME_S_1KI': 21.366477489471436, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 489.4337509441374, 'W': 19.31282985940674}
[16.76, 16.8, 16.72, 16.6, 16.36, 16.12, 16.0, 16.04, 16.28, 16.36, 16.6, 16.56, 16.28, 16.28, 16.28, 16.24, 16.56, 16.68, 16.52, 16.56]
295.46000000000004
14.773000000000001
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 1000, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [10000, 10000], 'MATRIX_ROWS': 10000, 'MATRIX_SIZE': 100000000, 'MATRIX_NNZ': 1000000, 'MATRIX_DENSITY': 0.01, 'TIME_S': 21.366477489471436, 'TIME_S_1KI': 21.366477489471436, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 489.4337509441374, 'W': 19.31282985940674, 'J_1KI': 489.4337509441374, 'W_1KI': 19.31282985940674, 'W_D': 4.539829859406739, 'J_D': 115.05025275492645, 'W_D_1KI': 4.539829859406739, 'J_D_1KI': 4.539829859406739}

1
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_10000_0.05.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Altra", "CORES": 16, "ITERATIONS": 1000, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 5000000, "MATRIX_DENSITY": 0.05, "TIME_S": 106.56549715995789, "TIME_S_1KI": 106.56549715995789, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 2685.1749729537964, "W": 24.108298502680796, "J_1KI": 2685.1749729537964, "W_1KI": 24.108298502680796, "W_D": 5.534298502680798, "J_D": 616.4084881644253, "W_D_1KI": 5.534298502680798, "J_D_1KI": 5.534298502680798}

45
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_10000_0.05.output Normal file
View File

@ -0,0 +1,45 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 1000 -ss 10000 -sd 0.05 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 5000000, "MATRIX_DENSITY": 0.05, "TIME_S": 106.56549715995789}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 506, 1012, ..., 4998963,
4999486, 5000000]),
col_indices=tensor([ 12, 18, 20, ..., 9951, 9962, 9995]),
values=tensor([0.8717, 0.8420, 0.2460, ..., 0.1141, 0.5771, 0.8192]),
size=(10000, 10000), nnz=5000000, layout=torch.sparse_csr)
tensor([0.3519, 0.6034, 0.3549, ..., 0.4924, 0.0253, 0.7056])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 5000000
Density: 0.05
Time: 106.56549715995789 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 506, 1012, ..., 4998963,
4999486, 5000000]),
col_indices=tensor([ 12, 18, 20, ..., 9951, 9962, 9995]),
values=tensor([0.8717, 0.8420, 0.2460, ..., 0.1141, 0.5771, 0.8192]),
size=(10000, 10000), nnz=5000000, layout=torch.sparse_csr)
tensor([0.3519, 0.6034, 0.3549, ..., 0.4924, 0.0253, 0.7056])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 5000000
Density: 0.05
Time: 106.56549715995789 seconds
[20.96, 20.76, 20.72, 20.52, 20.44, 20.56, 20.84, 20.84, 20.6, 20.6]
[20.64, 20.64, 21.08, 23.16, 24.52, 27.56, 29.68, 29.72, 28.4, 27.2, 27.2, 24.36, 24.36, 24.36, 24.84, 24.88, 24.76, 24.96, 24.72, 24.4, 24.36, 24.16, 24.12, 24.12, 24.24, 24.64, 24.72, 24.76, 24.88, 24.76, 24.4, 24.4, 24.32, 24.32, 24.24, 24.24, 24.44, 24.36, 24.16, 24.16, 24.2, 24.24, 24.4, 24.68, 24.56, 24.6, 24.52, 24.48, 24.48, 24.24, 24.36, 24.36, 24.44, 24.52, 24.52, 24.32, 24.44, 24.28, 24.04, 23.96, 23.96, 24.04, 24.16, 24.28, 24.36, 24.44, 24.48, 24.56, 24.64, 24.56, 24.48, 24.24, 24.24, 24.24, 24.2, 24.28, 24.36, 24.2, 24.4, 24.12, 24.16, 24.24, 24.48, 24.48, 24.8, 24.8, 24.92, 24.92, 24.96, 24.84, 24.72, 24.88, 24.72, 24.68, 24.48, 24.28, 24.0, 24.04, 24.04, 24.16, 24.32, 24.28, 24.32, 24.32, 24.48, 24.4, 24.68, 24.8, 24.64, 24.48]
111.37969660758972
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 1000, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [10000, 10000], 'MATRIX_ROWS': 10000, 'MATRIX_SIZE': 100000000, 'MATRIX_NNZ': 5000000, 'MATRIX_DENSITY': 0.05, 'TIME_S': 106.56549715995789, 'TIME_S_1KI': 106.56549715995789, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 2685.1749729537964, 'W': 24.108298502680796}
[20.96, 20.76, 20.72, 20.52, 20.44, 20.56, 20.84, 20.84, 20.6, 20.6, 20.64, 20.6, 20.6, 20.72, 20.8, 20.6, 20.52, 20.28, 20.68, 20.6]
371.47999999999996
18.573999999999998
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 1000, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [10000, 10000], 'MATRIX_ROWS': 10000, 'MATRIX_SIZE': 100000000, 'MATRIX_NNZ': 5000000, 'MATRIX_DENSITY': 0.05, 'TIME_S': 106.56549715995789, 'TIME_S_1KI': 106.56549715995789, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 2685.1749729537964, 'W': 24.108298502680796, 'J_1KI': 2685.1749729537964, 'W_1KI': 24.108298502680796, 'W_D': 5.534298502680798, 'J_D': 616.4084881644253, 'W_D_1KI': 5.534298502680798, 'J_D_1KI': 5.534298502680798}

1
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_10000_0.1.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Altra", "CORES": 16, "ITERATIONS": 1000, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 10000000, "MATRIX_DENSITY": 0.1, "TIME_S": 213.33555269241333, "TIME_S_1KI": 213.33555269241333, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 5226.200544624329, "W": 24.133137838334523, "J_1KI": 5226.200544624329, "W_1KI": 24.133137838334523, "W_D": 5.8551378383345245, "J_D": 1267.97123376751, "W_D_1KI": 5.8551378383345245, "J_D_1KI": 5.8551378383345245}

45
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_10000_0.1.output Normal file
View File

@ -0,0 +1,45 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 1000 -ss 10000 -sd 0.1 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 10000000, "MATRIX_DENSITY": 0.1, "TIME_S": 213.33555269241333}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 1053, 2094, ..., 9997974,
9998964, 10000000]),
col_indices=tensor([ 7, 12, 13, ..., 9961, 9986, 9993]),
values=tensor([0.1704, 0.0678, 0.1172, ..., 0.2208, 0.7370, 0.2820]),
size=(10000, 10000), nnz=10000000, layout=torch.sparse_csr)
tensor([0.7446, 0.0915, 0.8679, ..., 0.5982, 0.0596, 0.6566])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 10000000
Density: 0.1
Time: 213.33555269241333 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 1053, 2094, ..., 9997974,
9998964, 10000000]),
col_indices=tensor([ 7, 12, 13, ..., 9961, 9986, 9993]),
values=tensor([0.1704, 0.0678, 0.1172, ..., 0.2208, 0.7370, 0.2820]),
size=(10000, 10000), nnz=10000000, layout=torch.sparse_csr)
tensor([0.7446, 0.0915, 0.8679, ..., 0.5982, 0.0596, 0.6566])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 10000000
Density: 0.1
Time: 213.33555269241333 seconds
[20.4, 20.4, 20.4, 20.36, 20.36, 20.16, 20.32, 20.2, 20.2, 20.28]
[20.32, 20.48, 21.4, 22.68, 24.52, 24.52, 27.12, 28.4, 28.88, 28.48, 27.56, 25.92, 24.36, 24.48, 24.52, 24.56, 24.56, 24.24, 24.24, 24.2, 23.96, 23.92, 24.16, 24.36, 24.48, 24.52, 24.56, 24.56, 24.36, 24.28, 24.28, 24.48, 24.36, 24.36, 24.6, 24.36, 24.24, 24.2, 24.24, 24.12, 24.16, 24.12, 24.24, 24.24, 24.36, 24.48, 24.48, 24.56, 24.4, 24.4, 24.24, 24.56, 24.84, 24.76, 24.76, 24.76, 24.84, 24.52, 24.64, 24.64, 24.64, 24.64, 24.52, 24.52, 24.52, 24.4, 24.36, 24.36, 24.36, 24.32, 24.24, 24.44, 24.2, 24.08, 24.2, 24.0, 23.92, 23.88, 23.84, 24.08, 24.08, 24.4, 24.6, 24.72, 24.8, 24.68, 24.4, 24.36, 24.24, 24.12, 24.16, 24.2, 24.04, 24.04, 24.0, 24.12, 24.32, 24.36, 24.32, 24.4, 24.16, 24.08, 24.12, 24.32, 24.32, 24.32, 24.44, 24.56, 24.32, 24.36, 24.56, 24.68, 24.44, 24.48, 24.52, 24.44, 24.56, 24.56, 24.68, 24.6, 24.2, 24.6, 24.16, 24.24, 24.32, 24.56, 24.28, 24.48, 24.8, 24.68, 24.68, 24.84, 24.84, 24.84, 24.88, 24.56, 24.84, 24.68, 24.48, 24.76, 24.64, 24.64, 24.64, 24.52, 24.8, 24.68, 24.52, 24.68, 24.6, 24.44, 24.68, 24.76, 24.76, 24.64, 24.6, 24.6, 24.56, 24.44, 24.4, 24.52, 24.48, 24.44, 24.44, 24.32, 24.44, 24.28, 24.44, 24.44, 24.36, 24.16, 24.04, 24.0, 24.12, 24.0, 24.12, 24.4, 24.4, 24.32, 24.28, 24.28, 24.28, 24.2, 24.32, 24.32, 24.4, 24.6, 24.44, 24.56, 24.76, 24.84, 24.72, 24.72, 24.72, 24.56, 24.52, 24.56, 24.64, 24.6, 24.36, 24.44, 24.4, 24.4, 24.56, 24.72, 24.72, 24.6, 24.48, 24.36, 24.24, 24.24, 24.28, 24.44, 24.56, 24.56]
216.55702543258667
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 1000, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [10000, 10000], 'MATRIX_ROWS': 10000, 'MATRIX_SIZE': 100000000, 'MATRIX_NNZ': 10000000, 'MATRIX_DENSITY': 0.1, 'TIME_S': 213.33555269241333, 'TIME_S_1KI': 213.33555269241333, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 5226.200544624329, 'W': 24.133137838334523}
[20.4, 20.4, 20.4, 20.36, 20.36, 20.16, 20.32, 20.2, 20.2, 20.28, 20.2, 19.96, 20.08, 20.24, 20.24, 20.28, 20.48, 20.6, 20.64, 20.4]
365.55999999999995
18.278
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 1000, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [10000, 10000], 'MATRIX_ROWS': 10000, 'MATRIX_SIZE': 100000000, 'MATRIX_NNZ': 10000000, 'MATRIX_DENSITY': 0.1, 'TIME_S': 213.33555269241333, 'TIME_S_1KI': 213.33555269241333, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 5226.200544624329, 'W': 24.133137838334523, 'J_1KI': 5226.200544624329, 'W_1KI': 24.133137838334523, 'W_D': 5.8551378383345245, 'J_D': 1267.97123376751, 'W_D_1KI': 5.8551378383345245, 'J_D_1KI': 5.8551378383345245}

1
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_10000_0.2.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Altra", "CORES": 16, "ITERATIONS": 1000, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 20000000, "MATRIX_DENSITY": 0.2, "TIME_S": 424.4943735599518, "TIME_S_1KI": 424.4943735599518, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 10473.538437499996, "W": 24.301530579701517, "J_1KI": 10473.538437499996, "W_1KI": 24.301530579701517, "W_D": 5.865530579701517, "J_D": 2527.942006835934, "W_D_1KI": 5.865530579701517, "J_D_1KI": 5.865530579701517}

45
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_10000_0.2.output Normal file
View File

@ -0,0 +1,45 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 1000 -ss 10000 -sd 0.2 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 20000000, "MATRIX_DENSITY": 0.2, "TIME_S": 424.4943735599518}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 1949, 3966, ..., 19996026,
19998069, 20000000]),
col_indices=tensor([ 7, 21, 26, ..., 9986, 9990, 9999]),
values=tensor([0.4961, 0.8613, 0.9281, ..., 0.1556, 0.7430, 0.8560]),
size=(10000, 10000), nnz=20000000, layout=torch.sparse_csr)
tensor([0.5082, 0.3131, 0.5448, ..., 0.5922, 0.3726, 0.5476])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 20000000
Density: 0.2
Time: 424.4943735599518 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 1949, 3966, ..., 19996026,
19998069, 20000000]),
col_indices=tensor([ 7, 21, 26, ..., 9986, 9990, 9999]),
values=tensor([0.4961, 0.8613, 0.9281, ..., 0.1556, 0.7430, 0.8560]),
size=(10000, 10000), nnz=20000000, layout=torch.sparse_csr)
tensor([0.5082, 0.3131, 0.5448, ..., 0.5922, 0.3726, 0.5476])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 20000000
Density: 0.2
Time: 424.4943735599518 seconds
[20.56, 20.4, 20.48, 20.48, 20.56, 20.8, 20.96, 20.68, 20.68, 20.52]
[20.4, 20.4, 20.84, 23.24, 23.96, 25.96, 29.08, 30.08, 29.8, 30.04, 30.84, 27.8, 27.8, 27.2, 26.24, 24.6, 24.44, 24.32, 24.24, 24.32, 24.2, 24.44, 24.6, 24.6, 24.72, 24.72, 24.84, 24.88, 24.92, 24.96, 24.6, 24.48, 24.36, 24.16, 24.36, 24.64, 24.68, 24.68, 24.72, 24.68, 24.52, 24.52, 24.4, 24.44, 24.24, 24.36, 24.4, 24.48, 24.44, 24.44, 24.44, 24.24, 24.28, 24.24, 24.44, 24.4, 24.28, 24.24, 24.28, 24.24, 24.48, 24.84, 24.84, 24.56, 24.64, 24.6, 24.88, 24.68, 24.56, 24.56, 24.4, 24.4, 24.32, 24.36, 24.44, 24.44, 24.36, 24.48, 24.64, 24.8, 24.68, 24.92, 24.88, 24.76, 24.88, 24.68, 24.36, 24.36, 24.4, 24.44, 24.68, 24.76, 24.56, 24.64, 24.24, 24.32, 24.72, 24.6, 24.96, 24.96, 25.12, 25.04, 24.44, 24.36, 24.28, 24.16, 24.4, 24.44, 24.56, 24.68, 24.72, 24.48, 24.48, 24.4, 24.36, 24.24, 24.2, 24.52, 24.64, 24.84, 24.8, 24.56, 24.28, 24.16, 24.16, 24.16, 24.28, 24.4, 24.6, 24.64, 24.52, 24.56, 24.44, 24.36, 24.56, 24.84, 24.64, 24.64, 24.84, 24.72, 24.48, 24.6, 24.64, 24.68, 24.6, 24.4, 24.4, 24.16, 24.12, 24.12, 24.28, 24.4, 24.48, 24.76, 24.6, 24.44, 24.28, 24.32, 24.24, 24.32, 24.4, 24.4, 24.56, 24.48, 24.48, 24.28, 24.68, 24.52, 24.32, 24.4, 24.56, 24.28, 24.4, 24.72, 24.72, 24.76, 24.76, 24.72, 24.64, 24.56, 24.6, 24.56, 24.64, 24.48, 24.44, 24.4, 24.4, 24.36, 24.32, 24.48, 24.48, 24.48, 24.32, 24.4, 24.08, 24.16, 24.28, 24.44, 24.48, 24.48, 24.6, 24.56, 24.44, 24.4, 24.44, 24.44, 24.64, 24.72, 24.44, 24.48, 24.32, 24.32, 24.4, 24.28, 24.52, 24.56, 24.68, 24.68, 24.72, 24.88, 24.96, 25.04, 24.84, 24.84, 24.84, 24.6, 24.64, 24.6, 24.6, 24.6, 24.36, 24.28, 24.32, 24.48, 24.48, 24.44, 24.44, 24.56, 24.56, 24.84, 24.72, 24.8, 24.72, 24.6, 24.56, 24.68, 24.88, 24.88, 24.88, 24.88, 24.48, 24.48, 24.32, 24.32, 24.36, 24.36, 24.44, 24.32, 24.36, 24.44, 24.32, 24.32, 24.28, 24.64, 24.8, 24.8, 24.96, 24.76, 24.8, 24.68, 24.52, 24.64, 24.48, 24.48, 24.56, 24.48, 24.32, 24.28, 24.32, 24.36, 24.28, 24.36, 24.4, 24.28, 24.36, 24.36, 24.32, 24.16, 24.04, 24.2, 24.2, 24.32, 24.36, 24.52, 24.36, 24.44, 24.56, 24.64, 24.64, 24.84, 24.8, 24.8, 24.64, 24.48, 24.52, 24.4, 24.6, 24.32, 24.24, 24.2, 24.2, 24.16, 24.2, 24.56, 24.56, 24.68, 24.8, 24.8, 24.68, 24.64, 24.68, 24.6, 24.64, 24.64, 24.6, 24.6, 24.4, 24.28, 24.36, 24.4, 24.48, 24.44, 24.48, 24.52, 24.36, 24.36, 24.44, 24.32, 24.24, 24.44, 24.44, 24.68, 24.56, 24.4, 24.52, 24.4, 24.24, 24.24, 24.4, 24.44, 24.48, 24.6, 24.76, 24.76, 24.64, 24.72, 24.44, 24.48, 24.6, 24.56, 24.56, 24.64, 24.72, 24.56, 24.4, 24.24, 24.2, 24.16, 24.08, 24.04, 24.12, 24.32, 24.32, 24.36, 24.36, 24.6, 24.56, 24.52, 24.76, 24.6, 24.68, 24.56, 24.76, 24.8, 24.76, 24.76, 24.88, 24.64, 24.76, 24.52, 24.44, 24.2, 24.68, 24.48, 24.84, 25.0, 25.12, 25.12, 24.96, 24.84, 24.52, 24.28, 24.2, 24.48, 24.48, 24.52, 24.52, 24.56, 24.6, 24.6, 24.76, 24.76, 25.0, 24.88, 24.92, 24.88, 24.64, 24.72, 24.64, 24.68, 24.68, 24.56, 24.56, 24.36, 24.28, 24.32]
430.982666015625
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 1000, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [10000, 10000], 'MATRIX_ROWS': 10000, 'MATRIX_SIZE': 100000000, 'MATRIX_NNZ': 20000000, 'MATRIX_DENSITY': 0.2, 'TIME_S': 424.4943735599518, 'TIME_S_1KI': 424.4943735599518, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 10473.538437499996, 'W': 24.301530579701517}
[20.56, 20.4, 20.48, 20.48, 20.56, 20.8, 20.96, 20.68, 20.68, 20.52, 20.2, 20.36, 20.48, 20.56, 20.28, 20.2, 20.2, 20.24, 20.52, 20.4]
368.72
18.436
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 1000, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [10000, 10000], 'MATRIX_ROWS': 10000, 'MATRIX_SIZE': 100000000, 'MATRIX_NNZ': 20000000, 'MATRIX_DENSITY': 0.2, 'TIME_S': 424.4943735599518, 'TIME_S_1KI': 424.4943735599518, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 10473.538437499996, 'W': 24.301530579701517, 'J_1KI': 10473.538437499996, 'W_1KI': 24.301530579701517, 'W_D': 5.865530579701517, 'J_D': 2527.942006835934, 'W_D_1KI': 5.865530579701517, 'J_D_1KI': 5.865530579701517}

1
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_10000_0.3.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Altra", "CORES": 16, "ITERATIONS": 1000, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 30000000, "MATRIX_DENSITY": 0.3, "TIME_S": 637.8268127441406, "TIME_S_1KI": 637.8268127441406, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 15996.775521488189, "W": 24.370595996658984, "J_1KI": 15996.775521488189, "W_1KI": 24.370595996658984, "W_D": 5.917595996658985, "J_D": 3884.2896906743035, "W_D_1KI": 5.917595996658985, "J_D_1KI": 5.917595996658985}

45
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_10000_0.3.output Normal file
View File

@ -0,0 +1,45 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 1000 -ss 10000 -sd 0.3 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 30000000, "MATRIX_DENSITY": 0.3, "TIME_S": 637.8268127441406}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 2961, 5942, ..., 29993896,
29996981, 30000000]),
col_indices=tensor([ 2, 5, 14, ..., 9994, 9995, 9996]),
values=tensor([0.0155, 0.6045, 0.5805, ..., 0.2136, 0.4050, 0.0107]),
size=(10000, 10000), nnz=30000000, layout=torch.sparse_csr)
tensor([0.2173, 0.9101, 0.0107, ..., 0.2401, 0.6161, 0.6478])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 30000000
Density: 0.3
Time: 637.8268127441406 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 2961, 5942, ..., 29993896,
29996981, 30000000]),
col_indices=tensor([ 2, 5, 14, ..., 9994, 9995, 9996]),
values=tensor([0.0155, 0.6045, 0.5805, ..., 0.2136, 0.4050, 0.0107]),
size=(10000, 10000), nnz=30000000, layout=torch.sparse_csr)
tensor([0.2173, 0.9101, 0.0107, ..., 0.2401, 0.6161, 0.6478])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 30000000
Density: 0.3
Time: 637.8268127441406 seconds
[20.6, 20.64, 20.76, 20.6, 20.44, 20.44, 20.48, 20.64, 20.64, 20.88]
[20.96, 21.0, 21.0, 25.76, 26.8, 28.52, 29.6, 31.28, 31.2, 30.36, 31.16, 30.84, 30.84, 29.04, 28.4, 28.24, 27.2, 26.12, 24.68, 24.6, 24.44, 24.4, 24.4, 24.64, 24.72, 24.72, 24.96, 24.92, 24.64, 24.76, 24.76, 25.12, 25.12, 25.2, 24.92, 24.68, 24.48, 24.48, 24.6, 24.52, 24.44, 24.6, 24.48, 24.28, 24.24, 24.2, 24.32, 24.48, 24.6, 24.6, 24.56, 24.48, 24.4, 24.24, 24.28, 24.52, 24.4, 24.56, 24.56, 24.32, 24.48, 24.48, 24.48, 24.4, 24.64, 24.84, 24.76, 24.76, 24.8, 24.64, 24.56, 24.52, 24.28, 24.4, 24.4, 24.48, 24.72, 24.76, 24.68, 24.76, 24.76, 24.64, 24.64, 24.36, 24.2, 24.36, 24.36, 24.28, 24.48, 24.6, 24.4, 24.24, 24.4, 24.32, 24.36, 24.4, 24.52, 24.12, 24.36, 24.36, 24.6, 24.72, 24.56, 24.92, 24.48, 24.56, 24.56, 24.56, 24.16, 24.24, 24.24, 24.24, 24.36, 24.4, 24.56, 24.52, 24.72, 24.68, 24.8, 24.8, 24.76, 24.76, 24.64, 24.64, 24.64, 24.68, 24.52, 24.48, 24.56, 24.4, 24.6, 24.56, 24.6, 24.76, 24.76, 24.84, 24.84, 25.0, 24.92, 24.68, 24.72, 24.68, 24.84, 24.84, 24.72, 24.8, 24.64, 24.52, 24.52, 24.76, 24.8, 24.64, 24.6, 24.6, 24.56, 24.8, 25.0, 24.92, 24.8, 24.76, 24.52, 24.52, 24.44, 24.64, 24.76, 24.76, 24.64, 24.36, 24.36, 24.52, 24.56, 24.72, 24.96, 24.96, 24.76, 24.72, 24.84, 24.68, 24.52, 24.76, 24.68, 24.44, 24.52, 24.48, 24.52, 24.92, 24.92, 24.76, 24.52, 24.8, 24.68, 24.52, 24.72, 24.92, 24.6, 24.48, 24.44, 24.52, 24.52, 24.24, 24.4, 24.4, 24.4, 24.24, 24.28, 24.48, 24.44, 24.48, 24.8, 24.64, 24.64, 24.72, 24.8, 24.64, 24.52, 24.48, 24.28, 24.24, 24.2, 24.36, 24.4, 24.44, 24.44, 24.44, 24.72, 24.72, 24.76, 24.72, 24.8, 24.48, 24.24, 24.36, 24.36, 24.4, 24.64, 24.64, 24.76, 24.64, 24.56, 24.24, 24.32, 24.32, 24.4, 24.64, 24.76, 24.76, 24.92, 24.92, 24.96, 25.04, 24.76, 25.0, 24.8, 24.76, 24.72, 24.52, 24.52, 24.44, 24.6, 24.6, 24.6, 24.6, 24.64, 24.68, 24.68, 24.84, 25.0, 25.0, 24.88, 24.72, 24.56, 24.4, 24.4, 24.48, 24.52, 24.56, 24.44, 24.64, 24.56, 24.44, 24.36, 24.56, 24.72, 24.64, 24.92, 24.92, 24.84, 24.64, 24.68, 24.64, 24.68, 24.68, 24.8, 24.88, 24.88, 24.76, 24.96, 24.96, 24.76, 24.8, 24.64, 24.84, 24.68, 24.56, 24.72, 24.56, 24.56, 24.44, 24.28, 24.28, 24.36, 24.2, 24.04, 24.2, 24.32, 24.32, 24.52, 24.52, 24.4, 24.48, 24.72, 24.68, 24.68, 24.6, 24.68, 24.52, 24.52, 24.72, 24.64, 24.68, 24.8, 24.48, 24.6, 24.84, 24.84, 24.56, 24.56, 24.28, 24.24, 24.2, 24.32, 24.32, 24.16, 24.28, 24.44, 24.4, 24.4, 24.68, 24.84, 24.84, 24.76, 24.64, 24.6, 24.4, 24.56, 24.4, 24.4, 24.68, 24.8, 24.8, 24.72, 24.72, 24.56, 24.36, 24.48, 24.64, 24.72, 24.84, 24.88, 24.64, 24.6, 24.6, 24.56, 24.44, 24.44, 24.56, 24.6, 24.64, 24.48, 24.56, 24.28, 24.36, 24.44, 24.28, 24.28, 24.16, 24.24, 24.4, 24.36, 24.6, 24.64, 24.6, 24.6, 24.72, 24.84, 24.76, 24.76, 24.68, 24.68, 24.6, 24.52, 24.52, 24.48, 24.36, 24.32, 24.24, 24.2, 24.4, 24.4, 24.48, 24.52, 24.72, 24.68, 24.88, 24.88, 24.8, 24.92, 24.84, 24.76, 24.6, 24.44, 24.44, 24.4, 24.28, 24.24, 24.32, 24.16, 24.4, 24.52, 24.4, 24.28, 24.28, 24.2, 24.2, 24.08, 24.16, 24.28, 24.32, 24.4, 24.28, 24.24, 24.04, 24.04, 24.12, 24.16, 24.16, 24.4, 24.4, 24.48, 24.6, 24.76, 24.68, 24.6, 24.64, 24.48, 24.36, 24.36, 24.44, 24.44, 24.48, 24.72, 24.88, 24.64, 24.8, 24.64, 24.64, 24.6, 24.48, 24.48, 24.64, 24.64, 24.88, 24.64, 24.48, 24.36, 24.52, 24.48, 24.68, 24.88, 24.8, 24.92, 24.88, 24.88, 24.88, 25.04, 24.64, 24.8, 24.92, 24.8, 24.72, 24.72, 24.6, 24.4, 24.44, 24.52, 24.52, 24.36, 24.44, 24.6, 24.56, 24.48, 24.8, 24.72, 24.8, 24.72, 24.92, 24.68, 24.68, 24.52, 24.52, 24.48, 24.44, 24.36, 24.4, 24.36, 24.44, 24.4, 24.4, 24.32, 24.24, 24.24, 24.2, 24.12, 24.2, 24.36, 24.36, 24.52, 24.52, 24.4, 24.24, 24.24, 24.32, 24.32, 24.16, 24.2, 24.24, 24.28, 24.24, 24.44, 24.6, 24.44, 24.32, 24.4, 24.48, 24.48, 24.36, 24.68, 24.6, 24.52, 24.52, 24.52, 24.68, 24.48, 24.56, 24.44, 24.32, 24.28, 24.28, 24.24, 24.44, 24.4, 24.36, 24.24, 24.36, 24.72, 24.8, 24.64, 24.68, 24.44, 24.44, 24.44, 24.52, 24.68, 24.68, 24.84, 24.76, 24.96, 24.92, 24.92, 25.04, 25.48, 25.48, 25.16, 25.16, 24.76, 24.24, 24.32, 24.2, 24.32, 24.36, 24.4, 24.44, 24.56, 24.72, 24.72, 24.72, 24.64, 24.76, 24.6, 24.28, 24.12, 24.2, 24.24, 24.44, 25.04, 25.12, 25.12, 25.04, 25.08, 24.96, 24.64, 24.68, 24.88, 24.96, 25.12, 25.16, 25.16, 24.88, 25.08, 25.08, 25.12, 25.08, 24.84, 24.76, 24.56, 24.44, 24.68, 24.84, 24.64, 24.84, 24.76, 24.76, 24.56, 24.56, 24.8, 24.96, 24.96, 25.08, 24.92, 24.8, 24.76, 24.84, 24.76, 24.76, 24.8, 24.84, 24.72, 24.52, 24.6]
656.396565914154
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 1000, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [10000, 10000], 'MATRIX_ROWS': 10000, 'MATRIX_SIZE': 100000000, 'MATRIX_NNZ': 30000000, 'MATRIX_DENSITY': 0.3, 'TIME_S': 637.8268127441406, 'TIME_S_1KI': 637.8268127441406, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 15996.775521488189, 'W': 24.370595996658984}
[20.6, 20.64, 20.76, 20.6, 20.44, 20.44, 20.48, 20.64, 20.64, 20.88, 20.28, 20.44, 20.44, 20.64, 20.68, 20.44, 20.36, 20.36, 20.12, 20.12]
369.06
18.453
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 1000, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [10000, 10000], 'MATRIX_ROWS': 10000, 'MATRIX_SIZE': 100000000, 'MATRIX_NNZ': 30000000, 'MATRIX_DENSITY': 0.3, 'TIME_S': 637.8268127441406, 'TIME_S_1KI': 637.8268127441406, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 15996.775521488189, 'W': 24.370595996658984, 'J_1KI': 15996.775521488189, 'W_1KI': 24.370595996658984, 'W_D': 5.917595996658985, 'J_D': 3884.2896906743035, 'W_D_1KI': 5.917595996658985, 'J_D_1KI': 5.917595996658985}

1
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_10000_1e-05.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Altra", "CORES": 16, "ITERATIONS": 141920, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 1000, "MATRIX_DENSITY": 1e-05, "TIME_S": 10.197850227355957, "TIME_S_1KI": 0.0718563291104563, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 278.53162281036373, "W": 19.575620643059622, "J_1KI": 1.9625959893627658, "W_1KI": 0.1379341928062262, "W_D": 4.584620643059623, "J_D": 65.2322524514198, "W_D_1KI": 0.032304260449969154, "J_D_1KI": 0.00022762303022808028}

1307
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_10000_1e-05.output Normal file
View File

File diff suppressed because it is too large Load Diff

1
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_10000_5e-05.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Altra", "CORES": 16, "ITERATIONS": 52721, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 5000, "MATRIX_DENSITY": 5e-05, "TIME_S": 11.043588876724243, "TIME_S_1KI": 0.20947229522816796, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 310.41147632598876, "W": 21.8334966893401, "J_1KI": 5.8878146530981725, "W_1KI": 0.4141328254270613, "W_D": 3.2964966893401026, "J_D": 46.86699609327319, "W_D_1KI": 0.06252720337892116, "J_D_1KI": 0.0011860018470613448}

81
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_10000_5e-05.output Normal file
View File

@ -0,0 +1,81 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 1000 -ss 10000 -sd 5e-05 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 5000, "MATRIX_DENSITY": 5e-05, "TIME_S": 0.24570083618164062}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 0, 1, ..., 5000, 5000, 5000]),
col_indices=tensor([7274, 1823, 9481, ..., 3720, 7669, 6157]),
values=tensor([0.0699, 0.4403, 0.9366, ..., 0.7220, 0.3462, 0.9666]),
size=(10000, 10000), nnz=5000, layout=torch.sparse_csr)
tensor([0.3652, 0.9468, 0.8818, ..., 0.3143, 0.5478, 0.8274])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 5000
Density: 5e-05
Time: 0.24570083618164062 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 42734 -ss 10000 -sd 5e-05 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 5000, "MATRIX_DENSITY": 5e-05, "TIME_S": 8.510959386825562}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 0, 0, ..., 4999, 4999, 5000]),
col_indices=tensor([3889, 8009, 975, ..., 383, 3476, 3024]),
values=tensor([0.2888, 0.9236, 0.0703, ..., 0.2234, 0.4670, 0.5913]),
size=(10000, 10000), nnz=5000, layout=torch.sparse_csr)
tensor([0.8206, 0.5304, 0.1258, ..., 0.8056, 0.8493, 0.1547])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 5000
Density: 5e-05
Time: 8.510959386825562 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 52721 -ss 10000 -sd 5e-05 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 5000, "MATRIX_DENSITY": 5e-05, "TIME_S": 11.043588876724243}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 1, 1, ..., 4999, 5000, 5000]),
col_indices=tensor([3785, 9007, 8216, ..., 3831, 7720, 5051]),
values=tensor([0.5982, 0.6190, 0.5749, ..., 0.7670, 0.1287, 0.1052]),
size=(10000, 10000), nnz=5000, layout=torch.sparse_csr)
tensor([0.6986, 0.7258, 0.0612, ..., 0.6419, 0.7078, 0.3008])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 5000
Density: 5e-05
Time: 11.043588876724243 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 1, 1, ..., 4999, 5000, 5000]),
col_indices=tensor([3785, 9007, 8216, ..., 3831, 7720, 5051]),
values=tensor([0.5982, 0.6190, 0.5749, ..., 0.7670, 0.1287, 0.1052]),
size=(10000, 10000), nnz=5000, layout=torch.sparse_csr)
tensor([0.6986, 0.7258, 0.0612, ..., 0.6419, 0.7078, 0.3008])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 5000
Density: 5e-05
Time: 11.043588876724243 seconds
[20.64, 20.64, 20.64, 20.64, 20.48, 20.52, 20.4, 20.52, 20.6, 20.56]
[20.56, 20.6, 20.72, 22.44, 23.64, 25.6, 26.32, 25.84, 25.0, 23.2, 23.28, 23.24, 23.44, 23.44]
14.217213153839111
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 52721, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [10000, 10000], 'MATRIX_ROWS': 10000, 'MATRIX_SIZE': 100000000, 'MATRIX_NNZ': 5000, 'MATRIX_DENSITY': 5e-05, 'TIME_S': 11.043588876724243, 'TIME_S_1KI': 0.20947229522816796, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 310.41147632598876, 'W': 21.8334966893401}
[20.64, 20.64, 20.64, 20.64, 20.48, 20.52, 20.4, 20.52, 20.6, 20.56, 20.36, 20.48, 20.48, 20.44, 20.56, 20.68, 20.88, 20.96, 20.72, 20.64]
370.74
18.537
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 52721, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [10000, 10000], 'MATRIX_ROWS': 10000, 'MATRIX_SIZE': 100000000, 'MATRIX_NNZ': 5000, 'MATRIX_DENSITY': 5e-05, 'TIME_S': 11.043588876724243, 'TIME_S_1KI': 0.20947229522816796, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 310.41147632598876, 'W': 21.8334966893401, 'J_1KI': 5.8878146530981725, 'W_1KI': 0.4141328254270613, 'W_D': 3.2964966893401026, 'J_D': 46.86699609327319, 'W_D_1KI': 0.06252720337892116, 'J_D_1KI': 0.0011860018470613448}

1
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_500000_0.0001.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Altra", "CORES": 16, "ITERATIONS": 1000, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [500000, 500000], "MATRIX_ROWS": 500000, "MATRIX_SIZE": 250000000000, "MATRIX_NNZ": 25000000, "MATRIX_DENSITY": 0.0001, "TIME_S": 78.25872588157654, "TIME_S_1KI": 78.25872588157654, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 4354.838327121737, "W": 46.22946318790178, "J_1KI": 4354.838327121737, "W_1KI": 46.22946318790178, "W_D": 27.22746318790178, "J_D": 2564.8405165128734, "W_D_1KI": 27.22746318790178, "J_D_1KI": 27.22746318790178}

47
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_500000_0.0001.output Normal file
View File

@ -0,0 +1,47 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 1000 -ss 500000 -sd 0.0001 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [500000, 500000], "MATRIX_ROWS": 500000, "MATRIX_SIZE": 250000000000, "MATRIX_NNZ": 25000000, "MATRIX_DENSITY": 0.0001, "TIME_S": 78.25872588157654}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 62, 108, ..., 24999902,
24999957, 25000000]),
col_indices=tensor([ 8122, 13146, 17492, ..., 475877, 485043,
496973]),
values=tensor([0.3209, 0.8894, 0.3965, ..., 0.0269, 0.4047, 0.8747]),
size=(500000, 500000), nnz=25000000, layout=torch.sparse_csr)
tensor([0.9161, 0.4114, 0.3584, ..., 0.3416, 0.2120, 0.9282])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([500000, 500000])
Rows: 500000
Size: 250000000000
NNZ: 25000000
Density: 0.0001
Time: 78.25872588157654 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 62, 108, ..., 24999902,
24999957, 25000000]),
col_indices=tensor([ 8122, 13146, 17492, ..., 475877, 485043,
496973]),
values=tensor([0.3209, 0.8894, 0.3965, ..., 0.0269, 0.4047, 0.8747]),
size=(500000, 500000), nnz=25000000, layout=torch.sparse_csr)
tensor([0.9161, 0.4114, 0.3584, ..., 0.3416, 0.2120, 0.9282])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([500000, 500000])
Rows: 500000
Size: 250000000000
NNZ: 25000000
Density: 0.0001
Time: 78.25872588157654 seconds
[21.04, 21.2, 21.24, 21.2, 21.44, 21.2, 21.08, 21.04, 20.84, 20.8]
[20.96, 20.88, 21.6, 21.6, 22.56, 24.32, 26.6, 27.68, 30.32, 31.76, 31.8, 31.36, 31.8, 32.64, 38.12, 43.32, 49.08, 53.24, 53.16, 52.56, 52.56, 52.56, 52.6, 52.28, 52.68, 53.0, 53.04, 53.24, 53.08, 53.48, 53.36, 53.16, 53.16, 52.68, 52.84, 52.88, 53.12, 52.96, 52.88, 53.2, 53.16, 53.0, 53.0, 52.96, 53.12, 52.84, 52.76, 53.08, 52.96, 52.84, 52.96, 52.92, 53.12, 53.2, 53.04, 53.28, 53.16, 53.12, 52.68, 52.96, 52.88, 52.72, 53.04, 53.08, 52.76, 52.76, 52.92, 53.32, 53.28, 53.32, 53.44, 53.28, 53.32, 53.4, 53.48, 53.48, 53.4, 53.4, 53.44, 53.12, 53.32, 53.44, 53.56, 53.52, 53.4, 53.36, 53.12, 53.12, 53.12, 53.16]
94.20049524307251
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 1000, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [500000, 500000], 'MATRIX_ROWS': 500000, 'MATRIX_SIZE': 250000000000, 'MATRIX_NNZ': 25000000, 'MATRIX_DENSITY': 0.0001, 'TIME_S': 78.25872588157654, 'TIME_S_1KI': 78.25872588157654, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 4354.838327121737, 'W': 46.22946318790178}
[21.04, 21.2, 21.24, 21.2, 21.44, 21.2, 21.08, 21.04, 20.84, 20.8, 21.64, 21.52, 21.28, 21.2, 21.12, 20.8, 20.84, 20.76, 21.0, 21.08]
380.03999999999996
19.002
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 1000, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [500000, 500000], 'MATRIX_ROWS': 500000, 'MATRIX_SIZE': 250000000000, 'MATRIX_NNZ': 25000000, 'MATRIX_DENSITY': 0.0001, 'TIME_S': 78.25872588157654, 'TIME_S_1KI': 78.25872588157654, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 4354.838327121737, 'W': 46.22946318790178, 'J_1KI': 4354.838327121737, 'W_1KI': 46.22946318790178, 'W_D': 27.22746318790178, 'J_D': 2564.8405165128734, 'W_D_1KI': 27.22746318790178, 'J_D_1KI': 27.22746318790178}

1
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_500000_1e-05.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Altra", "CORES": 16, "ITERATIONS": 1484, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [500000, 500000], "MATRIX_ROWS": 500000, "MATRIX_SIZE": 250000000000, "MATRIX_NNZ": 2500000, "MATRIX_DENSITY": 1e-05, "TIME_S": 10.88543152809143, "TIME_S_1KI": 7.335196447500964, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 480.2575412559509, "W": 32.95171788766838, "J_1KI": 323.6236800916111, "W_1KI": 22.204661649372223, "W_D": 16.90171788766838, "J_D": 246.33548707246783, "W_D_1KI": 11.389297767970607, "J_D_1KI": 7.67472895415809}

68
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_500000_1e-05.output Normal file
View File

@ -0,0 +1,68 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 1000 -ss 500000 -sd 1e-05 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [500000, 500000], "MATRIX_ROWS": 500000, "MATRIX_SIZE": 250000000000, "MATRIX_NNZ": 2500000, "MATRIX_DENSITY": 1e-05, "TIME_S": 7.073613166809082}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 6, 13, ..., 2499990,
2499995, 2500000]),
col_indices=tensor([ 8141, 69274, 149925, ..., 390687, 407872,
439375]),
values=tensor([0.4271, 0.3560, 0.2859, ..., 0.3294, 0.0849, 0.5690]),
size=(500000, 500000), nnz=2500000, layout=torch.sparse_csr)
tensor([0.1896, 0.3447, 0.8973, ..., 0.8957, 0.5716, 0.6993])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([500000, 500000])
Rows: 500000
Size: 250000000000
NNZ: 2500000
Density: 1e-05
Time: 7.073613166809082 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 1484 -ss 500000 -sd 1e-05 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [500000, 500000], "MATRIX_ROWS": 500000, "MATRIX_SIZE": 250000000000, "MATRIX_NNZ": 2500000, "MATRIX_DENSITY": 1e-05, "TIME_S": 10.88543152809143}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 10, 15, ..., 2499994,
2500000, 2500000]),
col_indices=tensor([ 19808, 30523, 42041, ..., 253465, 473291,
475423]),
values=tensor([0.2655, 0.1335, 0.5252, ..., 0.0072, 0.8874, 0.1974]),
size=(500000, 500000), nnz=2500000, layout=torch.sparse_csr)
tensor([0.7673, 0.2797, 0.0430, ..., 0.8352, 0.7956, 0.1250])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([500000, 500000])
Rows: 500000
Size: 250000000000
NNZ: 2500000
Density: 1e-05
Time: 10.88543152809143 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 10, 15, ..., 2499994,
2500000, 2500000]),
col_indices=tensor([ 19808, 30523, 42041, ..., 253465, 473291,
475423]),
values=tensor([0.2655, 0.1335, 0.5252, ..., 0.0072, 0.8874, 0.1974]),
size=(500000, 500000), nnz=2500000, layout=torch.sparse_csr)
tensor([0.7673, 0.2797, 0.0430, ..., 0.8352, 0.7956, 0.1250])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([500000, 500000])
Rows: 500000
Size: 250000000000
NNZ: 2500000
Density: 1e-05
Time: 10.88543152809143 seconds
[20.16, 19.76, 19.4, 19.48, 19.12, 18.68, 18.6, 18.12, 18.12, 17.68]
[17.44, 17.16, 17.36, 21.36, 23.28, 27.36, 35.28, 38.6, 44.16, 47.92, 48.84, 48.56, 48.96, 49.04]
14.574582815170288
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 1484, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [500000, 500000], 'MATRIX_ROWS': 500000, 'MATRIX_SIZE': 250000000000, 'MATRIX_NNZ': 2500000, 'MATRIX_DENSITY': 1e-05, 'TIME_S': 10.88543152809143, 'TIME_S_1KI': 7.335196447500964, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 480.2575412559509, 'W': 32.95171788766838}
[20.16, 19.76, 19.4, 19.48, 19.12, 18.68, 18.6, 18.12, 18.12, 17.68, 16.68, 16.56, 16.56, 16.56, 16.72, 16.64, 16.76, 17.08, 17.04, 17.08]
321.0
16.05
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 1484, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [500000, 500000], 'MATRIX_ROWS': 500000, 'MATRIX_SIZE': 250000000000, 'MATRIX_NNZ': 2500000, 'MATRIX_DENSITY': 1e-05, 'TIME_S': 10.88543152809143, 'TIME_S_1KI': 7.335196447500964, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 480.2575412559509, 'W': 32.95171788766838, 'J_1KI': 323.6236800916111, 'W_1KI': 22.204661649372223, 'W_D': 16.90171788766838, 'J_D': 246.33548707246783, 'W_D_1KI': 11.389297767970607, 'J_D_1KI': 7.67472895415809}

1
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_500000_5e-05.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Altra", "CORES": 16, "ITERATIONS": 1000, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [500000, 500000], "MATRIX_ROWS": 500000, "MATRIX_SIZE": 250000000000, "MATRIX_NNZ": 12500000, "MATRIX_DENSITY": 5e-05, "TIME_S": 37.50764799118042, "TIME_S_1KI": 37.50764799118042, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 2045.1465811538696, "W": 43.475713756728496, "J_1KI": 2045.1465811538699, "W_1KI": 43.475713756728496, "W_D": 24.798713756728496, "J_D": 1166.5594483480452, "W_D_1KI": 24.798713756728496, "J_D_1KI": 24.798713756728496}

47
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_500000_5e-05.output Normal file
View File

@ -0,0 +1,47 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 1000 -ss 500000 -sd 5e-05 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [500000, 500000], "MATRIX_ROWS": 500000, "MATRIX_SIZE": 250000000000, "MATRIX_NNZ": 12500000, "MATRIX_DENSITY": 5e-05, "TIME_S": 37.50764799118042}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 37, 66, ..., 12499959,
12499977, 12500000]),
col_indices=tensor([ 2833, 12397, 17330, ..., 457394, 482426,
493028]),
values=tensor([0.7637, 0.4211, 0.1191, ..., 0.6468, 0.8330, 0.4871]),
size=(500000, 500000), nnz=12500000, layout=torch.sparse_csr)
tensor([0.3810, 0.7581, 0.5448, ..., 0.8790, 0.4682, 0.1184])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([500000, 500000])
Rows: 500000
Size: 250000000000
NNZ: 12500000
Density: 5e-05
Time: 37.50764799118042 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 37, 66, ..., 12499959,
12499977, 12500000]),
col_indices=tensor([ 2833, 12397, 17330, ..., 457394, 482426,
493028]),
values=tensor([0.7637, 0.4211, 0.1191, ..., 0.6468, 0.8330, 0.4871]),
size=(500000, 500000), nnz=12500000, layout=torch.sparse_csr)
tensor([0.3810, 0.7581, 0.5448, ..., 0.8790, 0.4682, 0.1184])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([500000, 500000])
Rows: 500000
Size: 250000000000
NNZ: 12500000
Density: 5e-05
Time: 37.50764799118042 seconds
[21.08, 20.96, 20.88, 20.72, 20.6, 20.6, 20.64, 20.2, 20.28, 20.6]
[20.72, 20.68, 21.2, 23.0, 24.88, 26.4, 29.84, 29.72, 30.96, 36.72, 36.72, 41.28, 45.64, 50.76, 52.76, 52.48, 53.28, 52.92, 52.8, 52.76, 52.48, 52.52, 52.68, 52.72, 53.4, 53.44, 53.4, 53.36, 53.12, 53.4, 53.2, 53.0, 53.0, 53.24, 53.08, 52.92, 53.0, 52.72, 52.8, 52.64, 52.8, 52.96, 52.8, 52.8, 52.68]
47.04112720489502
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 1000, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [500000, 500000], 'MATRIX_ROWS': 500000, 'MATRIX_SIZE': 250000000000, 'MATRIX_NNZ': 12500000, 'MATRIX_DENSITY': 5e-05, 'TIME_S': 37.50764799118042, 'TIME_S_1KI': 37.50764799118042, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 2045.1465811538696, 'W': 43.475713756728496}
[21.08, 20.96, 20.88, 20.72, 20.6, 20.6, 20.64, 20.2, 20.28, 20.6, 20.92, 21.12, 21.0, 20.84, 20.92, 20.72, 20.72, 20.56, 21.0, 20.96]
373.54
18.677
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 1000, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [500000, 500000], 'MATRIX_ROWS': 500000, 'MATRIX_SIZE': 250000000000, 'MATRIX_NNZ': 12500000, 'MATRIX_DENSITY': 5e-05, 'TIME_S': 37.50764799118042, 'TIME_S_1KI': 37.50764799118042, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 2045.1465811538696, 'W': 43.475713756728496, 'J_1KI': 2045.1465811538699, 'W_1KI': 43.475713756728496, 'W_D': 24.798713756728496, 'J_D': 1166.5594483480452, 'W_D_1KI': 24.798713756728496, 'J_D_1KI': 24.798713756728496}

1
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_50000_0.0001.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Altra", "CORES": 16, "ITERATIONS": 3392, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [50000, 50000], "MATRIX_ROWS": 50000, "MATRIX_SIZE": 2500000000, "MATRIX_NNZ": 250000, "MATRIX_DENSITY": 0.0001, "TIME_S": 10.727018594741821, "TIME_S_1KI": 3.1624465196762443, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 423.8805270671845, "W": 29.00744018011372, "J_1KI": 124.96477802688223, "W_1KI": 8.55172175121277, "W_D": 13.914440180113719, "J_D": 203.32922177100187, "W_D_1KI": 4.102134487061827, "J_D_1KI": 1.2093556860441705}

65
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_50000_0.0001.output Normal file
View File

@ -0,0 +1,65 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 1000 -ss 50000 -sd 0.0001 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [50000, 50000], "MATRIX_ROWS": 50000, "MATRIX_SIZE": 2500000000, "MATRIX_NNZ": 250000, "MATRIX_DENSITY": 0.0001, "TIME_S": 3.0953831672668457}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 6, 13, ..., 249985, 249991,
250000]),
col_indices=tensor([ 782, 10679, 21591, ..., 21721, 25862, 26402]),
values=tensor([0.1080, 0.2599, 0.9753, ..., 0.8598, 0.0309, 0.7621]),
size=(50000, 50000), nnz=250000, layout=torch.sparse_csr)
tensor([0.0624, 0.3415, 0.4601, ..., 0.0482, 0.7737, 0.1465])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([50000, 50000])
Rows: 50000
Size: 2500000000
NNZ: 250000
Density: 0.0001
Time: 3.0953831672668457 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 3392 -ss 50000 -sd 0.0001 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [50000, 50000], "MATRIX_ROWS": 50000, "MATRIX_SIZE": 2500000000, "MATRIX_NNZ": 250000, "MATRIX_DENSITY": 0.0001, "TIME_S": 10.727018594741821}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 3, 6, ..., 249992, 249997,
250000]),
col_indices=tensor([29888, 37512, 45145, ..., 10362, 27481, 28096]),
values=tensor([0.5987, 0.4413, 0.1210, ..., 0.9023, 0.1888, 0.1246]),
size=(50000, 50000), nnz=250000, layout=torch.sparse_csr)
tensor([0.0260, 0.0462, 0.3716, ..., 0.4992, 0.3586, 0.2225])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([50000, 50000])
Rows: 50000
Size: 2500000000
NNZ: 250000
Density: 0.0001
Time: 10.727018594741821 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 3, 6, ..., 249992, 249997,
250000]),
col_indices=tensor([29888, 37512, 45145, ..., 10362, 27481, 28096]),
values=tensor([0.5987, 0.4413, 0.1210, ..., 0.9023, 0.1888, 0.1246]),
size=(50000, 50000), nnz=250000, layout=torch.sparse_csr)
tensor([0.0260, 0.0462, 0.3716, ..., 0.4992, 0.3586, 0.2225])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([50000, 50000])
Rows: 50000
Size: 2500000000
NNZ: 250000
Density: 0.0001
Time: 10.727018594741821 seconds
[16.52, 16.28, 16.24, 16.16, 16.44, 16.44, 16.6, 16.52, 16.56, 16.68]
[16.44, 16.64, 17.44, 19.52, 22.44, 27.08, 32.32, 35.8, 38.92, 39.84, 40.12, 40.12, 40.24, 40.6]
14.612820863723755
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 3392, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [50000, 50000], 'MATRIX_ROWS': 50000, 'MATRIX_SIZE': 2500000000, 'MATRIX_NNZ': 250000, 'MATRIX_DENSITY': 0.0001, 'TIME_S': 10.727018594741821, 'TIME_S_1KI': 3.1624465196762443, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 423.8805270671845, 'W': 29.00744018011372}
[16.52, 16.28, 16.24, 16.16, 16.44, 16.44, 16.6, 16.52, 16.56, 16.68, 16.84, 16.68, 16.84, 17.24, 17.32, 17.48, 17.4, 17.24, 16.96, 16.88]
301.86
15.093
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 3392, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [50000, 50000], 'MATRIX_ROWS': 50000, 'MATRIX_SIZE': 2500000000, 'MATRIX_NNZ': 250000, 'MATRIX_DENSITY': 0.0001, 'TIME_S': 10.727018594741821, 'TIME_S_1KI': 3.1624465196762443, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 423.8805270671845, 'W': 29.00744018011372, 'J_1KI': 124.96477802688223, 'W_1KI': 8.55172175121277, 'W_D': 13.914440180113719, 'J_D': 203.32922177100187, 'W_D_1KI': 4.102134487061827, 'J_D_1KI': 1.2093556860441705}

1
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_50000_0.001.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Altra", "CORES": 16, "ITERATIONS": 1000, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [50000, 50000], "MATRIX_ROWS": 50000, "MATRIX_SIZE": 2500000000, "MATRIX_NNZ": 2500000, "MATRIX_DENSITY": 0.001, "TIME_S": 29.441463470458984, "TIME_S_1KI": 29.441463470458984, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 1067.5749865341186, "W": 32.87033016720936, "J_1KI": 1067.5749865341186, "W_1KI": 32.87033016720936, "W_D": 17.51733016720936, "J_D": 568.9344591989515, "W_D_1KI": 17.51733016720936, "J_D_1KI": 17.51733016720936}

45
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_50000_0.001.output Normal file
View File

@ -0,0 +1,45 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 1000 -ss 50000 -sd 0.001 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [50000, 50000], "MATRIX_ROWS": 50000, "MATRIX_SIZE": 2500000000, "MATRIX_NNZ": 2500000, "MATRIX_DENSITY": 0.001, "TIME_S": 29.441463470458984}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 37, 79, ..., 2499907,
2499951, 2500000]),
col_indices=tensor([ 2466, 3763, 4276, ..., 47502, 48879, 49149]),
values=tensor([0.0148, 0.9908, 0.2997, ..., 0.9281, 0.7443, 0.4383]),
size=(50000, 50000), nnz=2500000, layout=torch.sparse_csr)
tensor([0.6700, 0.5614, 0.5608, ..., 0.8928, 0.8615, 0.5607])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([50000, 50000])
Rows: 50000
Size: 2500000000
NNZ: 2500000
Density: 0.001
Time: 29.441463470458984 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 37, 79, ..., 2499907,
2499951, 2500000]),
col_indices=tensor([ 2466, 3763, 4276, ..., 47502, 48879, 49149]),
values=tensor([0.0148, 0.9908, 0.2997, ..., 0.9281, 0.7443, 0.4383]),
size=(50000, 50000), nnz=2500000, layout=torch.sparse_csr)
tensor([0.6700, 0.5614, 0.5608, ..., 0.8928, 0.8615, 0.5607])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([50000, 50000])
Rows: 50000
Size: 2500000000
NNZ: 2500000
Density: 0.001
Time: 29.441463470458984 seconds
[16.92, 17.36, 17.08, 16.84, 17.2, 17.28, 17.4, 17.44, 17.36, 17.36]
[17.08, 17.24, 17.08, 21.52, 22.36, 25.24, 29.48, 32.12, 34.64, 38.4, 38.76, 38.64, 38.8, 39.0, 39.0, 39.44, 39.4, 39.28, 39.32, 39.32, 39.24, 39.12, 39.0, 39.08, 39.32, 39.36, 39.28, 39.28, 39.16, 38.92, 39.08]
32.47837734222412
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 1000, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [50000, 50000], 'MATRIX_ROWS': 50000, 'MATRIX_SIZE': 2500000000, 'MATRIX_NNZ': 2500000, 'MATRIX_DENSITY': 0.001, 'TIME_S': 29.441463470458984, 'TIME_S_1KI': 29.441463470458984, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 1067.5749865341186, 'W': 32.87033016720936}
[16.92, 17.36, 17.08, 16.84, 17.2, 17.28, 17.4, 17.44, 17.36, 17.36, 16.68, 16.88, 16.76, 16.92, 16.84, 17.04, 17.0, 17.0, 16.68, 17.0]
307.06000000000006
15.353000000000003
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 1000, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [50000, 50000], 'MATRIX_ROWS': 50000, 'MATRIX_SIZE': 2500000000, 'MATRIX_NNZ': 2500000, 'MATRIX_DENSITY': 0.001, 'TIME_S': 29.441463470458984, 'TIME_S_1KI': 29.441463470458984, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 1067.5749865341186, 'W': 32.87033016720936, 'J_1KI': 1067.5749865341186, 'W_1KI': 32.87033016720936, 'W_D': 17.51733016720936, 'J_D': 568.9344591989515, 'W_D_1KI': 17.51733016720936, 'J_D_1KI': 17.51733016720936}

1
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_50000_0.01.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Altra", "CORES": 16, "ITERATIONS": 1000, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [50000, 50000], "MATRIX_ROWS": 50000, "MATRIX_SIZE": 2500000000, "MATRIX_NNZ": 25000000, "MATRIX_DENSITY": 0.01, "TIME_S": 324.79648518562317, "TIME_S_1KI": 324.79648518562317, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 11877.425473241823, "W": 35.646067141867775, "J_1KI": 11877.425473241823, "W_1KI": 35.646067141867775, "W_D": 16.970067141867776, "J_D": 5654.50059192373, "W_D_1KI": 16.970067141867776, "J_D_1KI": 16.970067141867776}

45
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_50000_0.01.output Normal file
View File

@ -0,0 +1,45 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 1000 -ss 50000 -sd 0.01 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [50000, 50000], "MATRIX_ROWS": 50000, "MATRIX_SIZE": 2500000000, "MATRIX_NNZ": 25000000, "MATRIX_DENSITY": 0.01, "TIME_S": 324.79648518562317}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 495, 976, ..., 24999061,
24999546, 25000000]),
col_indices=tensor([ 151, 490, 496, ..., 49361, 49363, 49505]),
values=tensor([0.8177, 0.6830, 0.3837, ..., 0.7178, 0.0658, 0.9045]),
size=(50000, 50000), nnz=25000000, layout=torch.sparse_csr)
tensor([0.7632, 0.2578, 0.8207, ..., 0.6267, 0.5426, 0.4264])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([50000, 50000])
Rows: 50000
Size: 2500000000
NNZ: 25000000
Density: 0.01
Time: 324.79648518562317 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 495, 976, ..., 24999061,
24999546, 25000000]),
col_indices=tensor([ 151, 490, 496, ..., 49361, 49363, 49505]),
values=tensor([0.8177, 0.6830, 0.3837, ..., 0.7178, 0.0658, 0.9045]),
size=(50000, 50000), nnz=25000000, layout=torch.sparse_csr)
tensor([0.7632, 0.2578, 0.8207, ..., 0.6267, 0.5426, 0.4264])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([50000, 50000])
Rows: 50000
Size: 2500000000
NNZ: 25000000
Density: 0.01
Time: 324.79648518562317 seconds
[20.76, 20.6, 20.88, 20.96, 20.84, 20.88, 20.88, 20.68, 20.8, 20.88]
[21.16, 21.04, 21.12, 26.2, 28.16, 29.12, 31.64, 29.84, 30.96, 30.96, 31.32, 31.32, 31.52, 31.84, 31.92, 33.6, 35.32, 36.84, 37.0, 36.88, 36.84, 36.12, 36.76, 36.76, 36.4, 37.24, 37.32, 37.12, 37.84, 37.0, 37.76, 37.32, 37.0, 35.96, 36.28, 35.4, 35.8, 36.36, 37.12, 37.12, 38.8, 38.96, 38.72, 38.44, 37.4, 38.36, 38.0, 38.04, 37.84, 37.56, 36.92, 36.92, 36.84, 36.48, 36.64, 36.64, 36.52, 35.64, 36.12, 36.84, 37.56, 37.52, 38.6, 37.96, 37.32, 37.44, 36.76, 37.36, 37.44, 37.76, 37.8, 37.8, 38.68, 38.12, 37.96, 37.72, 37.88, 37.92, 37.84, 36.92, 36.6, 36.4, 36.48, 36.4, 37.2, 37.04, 37.16, 36.8, 36.8, 36.72, 37.72, 38.0, 37.96, 37.76, 37.08, 37.48, 36.64, 36.8, 36.88, 37.2, 37.24, 37.44, 37.48, 38.04, 38.04, 38.16, 38.68, 37.96, 38.24, 37.16, 36.68, 36.84, 36.88, 37.16, 37.76, 37.92, 37.76, 37.56, 36.52, 36.0, 37.0, 36.44, 36.36, 36.68, 37.08, 37.4, 37.24, 37.32, 36.6, 36.2, 37.16, 37.32, 37.6, 37.6, 37.6, 37.56, 37.56, 37.24, 36.48, 36.28, 36.48, 36.64, 37.68, 38.24, 37.72, 37.64, 38.24, 37.6, 37.0, 37.0, 36.88, 36.88, 37.28, 38.48, 39.08, 38.28, 38.04, 37.48, 36.64, 36.72, 36.84, 36.84, 37.2, 37.36, 37.76, 37.96, 38.24, 37.88, 37.88, 37.12, 37.6, 36.76, 37.52, 37.68, 36.76, 37.72, 37.48, 38.04, 37.88, 37.6, 37.56, 36.96, 37.0, 37.0, 37.92, 37.08, 37.44, 36.8, 36.84, 36.08, 36.52, 36.48, 36.56, 36.84, 37.2, 37.36, 36.52, 37.0, 36.12, 36.12, 37.0, 36.68, 36.88, 37.56, 37.72, 38.36, 38.2, 38.48, 38.72, 38.36, 38.28, 37.96, 37.76, 36.36, 37.0, 36.48, 36.52, 36.52, 37.16, 36.6, 36.52, 36.6, 37.52, 37.12, 37.8, 37.88, 37.04, 36.64, 36.44, 36.04, 36.32, 37.68, 37.88, 37.88, 38.04, 38.04, 37.68, 37.92, 37.96, 36.92, 37.64, 36.4, 36.32, 36.4, 36.32, 36.2, 37.04, 37.16, 37.68, 37.64, 37.64, 38.12, 38.04, 37.64, 37.24, 36.56, 36.48, 37.28, 36.6, 36.44, 37.08, 37.08, 36.56, 37.48, 38.08, 37.2, 37.2, 36.96, 36.72, 36.64, 36.24, 37.32, 37.96, 38.2, 38.28, 38.36, 38.36, 37.88, 38.36, 37.64, 36.88, 36.88, 37.2, 36.4, 36.52, 37.2, 37.52, 37.44, 36.8, 37.48, 36.92, 37.32, 38.0, 37.76, 36.72, 37.84, 37.64, 37.64, 38.32, 38.32, 37.88, 38.16, 38.24, 37.64, 37.76, 37.12, 37.04, 36.24, 36.68, 36.4, 36.6, 36.6, 36.64, 37.16, 38.08, 37.28, 37.28, 37.24, 36.52, 36.4, 36.88, 36.2, 36.92]
333.20437359809875
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 1000, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [50000, 50000], 'MATRIX_ROWS': 50000, 'MATRIX_SIZE': 2500000000, 'MATRIX_NNZ': 25000000, 'MATRIX_DENSITY': 0.01, 'TIME_S': 324.79648518562317, 'TIME_S_1KI': 324.79648518562317, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 11877.425473241823, 'W': 35.646067141867775}
[20.76, 20.6, 20.88, 20.96, 20.84, 20.88, 20.88, 20.68, 20.8, 20.88, 20.44, 20.44, 20.64, 20.68, 20.68, 20.68, 20.68, 20.84, 20.88, 20.88]
373.52
18.676
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 1000, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [50000, 50000], 'MATRIX_ROWS': 50000, 'MATRIX_SIZE': 2500000000, 'MATRIX_NNZ': 25000000, 'MATRIX_DENSITY': 0.01, 'TIME_S': 324.79648518562317, 'TIME_S_1KI': 324.79648518562317, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 11877.425473241823, 'W': 35.646067141867775, 'J_1KI': 11877.425473241823, 'W_1KI': 35.646067141867775, 'W_D': 16.970067141867776, 'J_D': 5654.50059192373, 'W_D_1KI': 16.970067141867776, 'J_D_1KI': 16.970067141867776}

1
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_50000_1e-05.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Altra", "CORES": 16, "ITERATIONS": 20098, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [50000, 50000], "MATRIX_ROWS": 50000, "MATRIX_SIZE": 2500000000, "MATRIX_NNZ": 25000, "MATRIX_DENSITY": 1e-05, "TIME_S": 10.650188207626343, "TIME_S_1KI": 0.5299128374776765, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 402.8303679275513, "W": 27.52967890413959, "J_1KI": 20.04330619601708, "W_1KI": 1.3697720621026763, "W_D": 12.350678904139592, "J_D": 180.72235947370535, "W_D_1KI": 0.6145227835674988, "J_D_1KI": 0.030576315233729664}

81
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_50000_1e-05.output Normal file
View File

@ -0,0 +1,81 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 1000 -ss 50000 -sd 1e-05 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [50000, 50000], "MATRIX_ROWS": 50000, "MATRIX_SIZE": 2500000000, "MATRIX_NNZ": 25000, "MATRIX_DENSITY": 1e-05, "TIME_S": 0.648245096206665}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 0, 0, ..., 24997, 24999, 25000]),
col_indices=tensor([ 889, 16856, 49649, ..., 20622, 24354, 47394]),
values=tensor([0.8512, 0.0995, 0.9072, ..., 0.9114, 0.3857, 0.4483]),
size=(50000, 50000), nnz=25000, layout=torch.sparse_csr)
tensor([0.8531, 0.5584, 0.8209, ..., 0.8853, 0.7506, 0.6837])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([50000, 50000])
Rows: 50000
Size: 2500000000
NNZ: 25000
Density: 1e-05
Time: 0.648245096206665 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 16197 -ss 50000 -sd 1e-05 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [50000, 50000], "MATRIX_ROWS": 50000, "MATRIX_SIZE": 2500000000, "MATRIX_NNZ": 25000, "MATRIX_DENSITY": 1e-05, "TIME_S": 8.461615800857544}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 1, 1, ..., 25000, 25000, 25000]),
col_indices=tensor([37259, 33129, 13575, ..., 31298, 24333, 9136]),
values=tensor([0.0302, 0.8728, 0.1875, ..., 0.5590, 0.6136, 0.6206]),
size=(50000, 50000), nnz=25000, layout=torch.sparse_csr)
tensor([0.6191, 0.3887, 0.4199, ..., 0.2754, 0.8424, 0.8817])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([50000, 50000])
Rows: 50000
Size: 2500000000
NNZ: 25000
Density: 1e-05
Time: 8.461615800857544 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 20098 -ss 50000 -sd 1e-05 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [50000, 50000], "MATRIX_ROWS": 50000, "MATRIX_SIZE": 2500000000, "MATRIX_NNZ": 25000, "MATRIX_DENSITY": 1e-05, "TIME_S": 10.650188207626343}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 1, 2, ..., 24999, 25000, 25000]),
col_indices=tensor([ 35, 8013, 35741, ..., 26171, 43365, 6398]),
values=tensor([0.7135, 0.5997, 0.1893, ..., 0.8752, 0.2236, 0.9882]),
size=(50000, 50000), nnz=25000, layout=torch.sparse_csr)
tensor([0.7523, 0.4685, 0.7648, ..., 0.0829, 0.9708, 0.7467])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([50000, 50000])
Rows: 50000
Size: 2500000000
NNZ: 25000
Density: 1e-05
Time: 10.650188207626343 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 1, 2, ..., 24999, 25000, 25000]),
col_indices=tensor([ 35, 8013, 35741, ..., 26171, 43365, 6398]),
values=tensor([0.7135, 0.5997, 0.1893, ..., 0.8752, 0.2236, 0.9882]),
size=(50000, 50000), nnz=25000, layout=torch.sparse_csr)
tensor([0.7523, 0.4685, 0.7648, ..., 0.0829, 0.9708, 0.7467])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([50000, 50000])
Rows: 50000
Size: 2500000000
NNZ: 25000
Density: 1e-05
Time: 10.650188207626343 seconds
[16.64, 16.56, 16.56, 16.96, 17.08, 17.16, 16.88, 16.96, 16.48, 16.36]
[16.44, 16.44, 16.68, 18.12, 19.04, 22.72, 28.64, 33.16, 36.92, 39.76, 39.32, 39.28, 39.68, 39.6]
14.632585048675537
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 20098, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [50000, 50000], 'MATRIX_ROWS': 50000, 'MATRIX_SIZE': 2500000000, 'MATRIX_NNZ': 25000, 'MATRIX_DENSITY': 1e-05, 'TIME_S': 10.650188207626343, 'TIME_S_1KI': 0.5299128374776765, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 402.8303679275513, 'W': 27.52967890413959}
[16.64, 16.56, 16.56, 16.96, 17.08, 17.16, 16.88, 16.96, 16.48, 16.36, 17.12, 16.92, 16.68, 16.88, 16.76, 16.8, 16.8, 17.12, 17.32, 17.2]
303.58
15.178999999999998
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 20098, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [50000, 50000], 'MATRIX_ROWS': 50000, 'MATRIX_SIZE': 2500000000, 'MATRIX_NNZ': 25000, 'MATRIX_DENSITY': 1e-05, 'TIME_S': 10.650188207626343, 'TIME_S_1KI': 0.5299128374776765, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 402.8303679275513, 'W': 27.52967890413959, 'J_1KI': 20.04330619601708, 'W_1KI': 1.3697720621026763, 'W_D': 12.350678904139592, 'J_D': 180.72235947370535, 'W_D_1KI': 0.6145227835674988, 'J_D_1KI': 0.030576315233729664}

1
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_50000_5e-05.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Altra", "CORES": 16, "ITERATIONS": 6265, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [50000, 50000], "MATRIX_ROWS": 50000, "MATRIX_SIZE": 2500000000, "MATRIX_NNZ": 125000, "MATRIX_DENSITY": 5e-05, "TIME_S": 10.399809837341309, "TIME_S_1KI": 1.6599856085141753, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 409.2376235961914, "W": 30.158092261325162, "J_1KI": 65.32124877832264, "W_1KI": 4.813741781536339, "W_D": 11.570092261325161, "J_D": 157.0032023506164, "W_D_1KI": 1.846782483850784, "J_D_1KI": 0.2947777308620565}

65
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_50000_5e-05.output Normal file
View File

@ -0,0 +1,65 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 1000 -ss 50000 -sd 5e-05 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [50000, 50000], "MATRIX_ROWS": 50000, "MATRIX_SIZE": 2500000000, "MATRIX_NNZ": 125000, "MATRIX_DENSITY": 5e-05, "TIME_S": 1.6757559776306152}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 3, 4, ..., 124996, 124997,
125000]),
col_indices=tensor([11324, 36531, 41582, ..., 26561, 37075, 42675]),
values=tensor([0.0907, 0.5500, 0.9495, ..., 0.7742, 0.3202, 0.5187]),
size=(50000, 50000), nnz=125000, layout=torch.sparse_csr)
tensor([0.4295, 0.8994, 0.1269, ..., 0.0289, 0.7051, 0.4729])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([50000, 50000])
Rows: 50000
Size: 2500000000
NNZ: 125000
Density: 5e-05
Time: 1.6757559776306152 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 6265 -ss 50000 -sd 5e-05 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [50000, 50000], "MATRIX_ROWS": 50000, "MATRIX_SIZE": 2500000000, "MATRIX_NNZ": 125000, "MATRIX_DENSITY": 5e-05, "TIME_S": 10.399809837341309}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 3, 6, ..., 124998, 125000,
125000]),
col_indices=tensor([ 5059, 34750, 35724, ..., 34703, 6591, 31118]),
values=tensor([0.4217, 0.1867, 0.1593, ..., 0.5339, 0.2274, 0.5888]),
size=(50000, 50000), nnz=125000, layout=torch.sparse_csr)
tensor([0.7798, 0.1756, 0.8709, ..., 0.5047, 0.8577, 0.3016])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([50000, 50000])
Rows: 50000
Size: 2500000000
NNZ: 125000
Density: 5e-05
Time: 10.399809837341309 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 3, 6, ..., 124998, 125000,
125000]),
col_indices=tensor([ 5059, 34750, 35724, ..., 34703, 6591, 31118]),
values=tensor([0.4217, 0.1867, 0.1593, ..., 0.5339, 0.2274, 0.5888]),
size=(50000, 50000), nnz=125000, layout=torch.sparse_csr)
tensor([0.7798, 0.1756, 0.8709, ..., 0.5047, 0.8577, 0.3016])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([50000, 50000])
Rows: 50000
Size: 2500000000
NNZ: 125000
Density: 5e-05
Time: 10.399809837341309 seconds
[20.92, 20.84, 20.96, 20.84, 20.68, 20.64, 20.84, 20.76, 20.84, 21.08]
[21.08, 21.16, 21.84, 21.84, 23.04, 26.04, 31.36, 35.8, 40.08, 43.12, 43.68, 43.84, 43.84]
13.569745063781738
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 6265, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [50000, 50000], 'MATRIX_ROWS': 50000, 'MATRIX_SIZE': 2500000000, 'MATRIX_NNZ': 125000, 'MATRIX_DENSITY': 5e-05, 'TIME_S': 10.399809837341309, 'TIME_S_1KI': 1.6599856085141753, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 409.2376235961914, 'W': 30.158092261325162}
[20.92, 20.84, 20.96, 20.84, 20.68, 20.64, 20.84, 20.76, 20.84, 21.08, 20.04, 19.96, 20.16, 20.28, 20.56, 20.88, 20.76, 20.68, 20.68, 20.76]
371.76000000000005
18.588
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 6265, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [50000, 50000], 'MATRIX_ROWS': 50000, 'MATRIX_SIZE': 2500000000, 'MATRIX_NNZ': 125000, 'MATRIX_DENSITY': 5e-05, 'TIME_S': 10.399809837341309, 'TIME_S_1KI': 1.6599856085141753, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 409.2376235961914, 'W': 30.158092261325162, 'J_1KI': 65.32124877832264, 'W_1KI': 4.813741781536339, 'W_D': 11.570092261325161, 'J_D': 157.0032023506164, 'W_D_1KI': 1.846782483850784, 'J_D_1KI': 0.2947777308620565}

1
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_5000_0.0001.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Altra", "CORES": 16, "ITERATIONS": 96690, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [5000, 5000], "MATRIX_ROWS": 5000, "MATRIX_SIZE": 25000000, "MATRIX_NNZ": 2500, "MATRIX_DENSITY": 0.0001, "TIME_S": 10.663233041763306, "TIME_S_1KI": 0.11028268736956569, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 262.53495136260995, "W": 18.48739374467239, "J_1KI": 2.7152234084456506, "W_1KI": 0.19120274841940624, "W_D": 3.6973937446723912, "J_D": 52.505783147812, "W_D_1KI": 0.038239670541652615, "J_D_1KI": 0.0003954873362462779}

81
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_5000_0.0001.output Normal file
View File

@ -0,0 +1,81 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 1000 -ss 5000 -sd 0.0001 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [5000, 5000], "MATRIX_ROWS": 5000, "MATRIX_SIZE": 25000000, "MATRIX_NNZ": 2500, "MATRIX_DENSITY": 0.0001, "TIME_S": 0.11520600318908691}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 1, 1, ..., 2498, 2498, 2500]),
col_indices=tensor([4712, 1560, 1507, ..., 2651, 244, 3781]),
values=tensor([0.1646, 0.3564, 0.3355, ..., 0.5785, 0.6935, 0.4198]),
size=(5000, 5000), nnz=2500, layout=torch.sparse_csr)
tensor([0.6842, 0.2217, 0.0992, ..., 0.1824, 0.3701, 0.4149])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([5000, 5000])
Rows: 5000
Size: 25000000
NNZ: 2500
Density: 0.0001
Time: 0.11520600318908691 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 91141 -ss 5000 -sd 0.0001 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [5000, 5000], "MATRIX_ROWS": 5000, "MATRIX_SIZE": 25000000, "MATRIX_NNZ": 2500, "MATRIX_DENSITY": 0.0001, "TIME_S": 9.897401094436646}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 0, 0, ..., 2499, 2500, 2500]),
col_indices=tensor([1451, 2006, 3586, ..., 3975, 4446, 2086]),
values=tensor([0.6609, 0.8356, 0.1353, ..., 0.7408, 0.3224, 0.8471]),
size=(5000, 5000), nnz=2500, layout=torch.sparse_csr)
tensor([0.2892, 0.1223, 0.3419, ..., 0.7884, 0.7802, 0.0113])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([5000, 5000])
Rows: 5000
Size: 25000000
NNZ: 2500
Density: 0.0001
Time: 9.897401094436646 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 96690 -ss 5000 -sd 0.0001 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [5000, 5000], "MATRIX_ROWS": 5000, "MATRIX_SIZE": 25000000, "MATRIX_NNZ": 2500, "MATRIX_DENSITY": 0.0001, "TIME_S": 10.663233041763306}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 0, 2, ..., 2499, 2499, 2500]),
col_indices=tensor([2205, 2444, 2425, ..., 3761, 2544, 2990]),
values=tensor([0.2656, 0.9114, 0.3983, ..., 0.8675, 0.7517, 0.7885]),
size=(5000, 5000), nnz=2500, layout=torch.sparse_csr)
tensor([0.1659, 0.6941, 0.7553, ..., 0.7483, 0.8019, 0.7277])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([5000, 5000])
Rows: 5000
Size: 25000000
NNZ: 2500
Density: 0.0001
Time: 10.663233041763306 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 0, 2, ..., 2499, 2499, 2500]),
col_indices=tensor([2205, 2444, 2425, ..., 3761, 2544, 2990]),
values=tensor([0.2656, 0.9114, 0.3983, ..., 0.8675, 0.7517, 0.7885]),
size=(5000, 5000), nnz=2500, layout=torch.sparse_csr)
tensor([0.1659, 0.6941, 0.7553, ..., 0.7483, 0.8019, 0.7277])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([5000, 5000])
Rows: 5000
Size: 25000000
NNZ: 2500
Density: 0.0001
Time: 10.663233041763306 seconds
[16.32, 16.04, 16.32, 16.56, 16.56, 16.64, 16.96, 16.96, 16.76, 16.76]
[16.76, 16.88, 17.08, 18.96, 20.48, 21.96, 22.64, 22.36, 21.0, 19.8, 19.8, 19.6, 19.72, 19.8]
14.20075511932373
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 96690, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [5000, 5000], 'MATRIX_ROWS': 5000, 'MATRIX_SIZE': 25000000, 'MATRIX_NNZ': 2500, 'MATRIX_DENSITY': 0.0001, 'TIME_S': 10.663233041763306, 'TIME_S_1KI': 0.11028268736956569, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 262.53495136260995, 'W': 18.48739374467239}
[16.32, 16.04, 16.32, 16.56, 16.56, 16.64, 16.96, 16.96, 16.76, 16.76, 16.48, 16.4, 16.2, 16.28, 16.28, 16.12, 16.12, 16.28, 16.36, 16.36]
295.79999999999995
14.789999999999997
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 96690, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [5000, 5000], 'MATRIX_ROWS': 5000, 'MATRIX_SIZE': 25000000, 'MATRIX_NNZ': 2500, 'MATRIX_DENSITY': 0.0001, 'TIME_S': 10.663233041763306, 'TIME_S_1KI': 0.11028268736956569, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 262.53495136260995, 'W': 18.48739374467239, 'J_1KI': 2.7152234084456506, 'W_1KI': 0.19120274841940624, 'W_D': 3.6973937446723912, 'J_D': 52.505783147812, 'W_D_1KI': 0.038239670541652615, 'J_D_1KI': 0.0003954873362462779}

1
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_5000_0.001.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Altra", "CORES": 16, "ITERATIONS": 17852, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [5000, 5000], "MATRIX_ROWS": 5000, "MATRIX_SIZE": 25000000, "MATRIX_NNZ": 25000, "MATRIX_DENSITY": 0.001, "TIME_S": 10.54783010482788, "TIME_S_1KI": 0.5908486502816425, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 261.2027643966674, "W": 18.408959018952206, "J_1KI": 14.6315686979984, "W_1KI": 1.0311986902841253, "W_D": 3.4579590189522076, "J_D": 49.0646132674217, "W_D_1KI": 0.19370149109075777, "J_D_1KI": 0.010850408418707023}

81
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_5000_0.001.output Normal file
View File

@ -0,0 +1,81 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 1000 -ss 5000 -sd 0.001 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [5000, 5000], "MATRIX_ROWS": 5000, "MATRIX_SIZE": 25000000, "MATRIX_NNZ": 25000, "MATRIX_DENSITY": 0.001, "TIME_S": 0.6220724582672119}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 1, 4, ..., 24988, 24993, 25000]),
col_indices=tensor([2208, 3192, 3630, ..., 2657, 2751, 4682]),
values=tensor([0.3516, 0.9043, 0.4344, ..., 0.9354, 0.2858, 0.8708]),
size=(5000, 5000), nnz=25000, layout=torch.sparse_csr)
tensor([0.1847, 0.5253, 0.6086, ..., 0.9552, 0.0514, 0.1920])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([5000, 5000])
Rows: 5000
Size: 25000000
NNZ: 25000
Density: 0.001
Time: 0.6220724582672119 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 16879 -ss 5000 -sd 0.001 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [5000, 5000], "MATRIX_ROWS": 5000, "MATRIX_SIZE": 25000000, "MATRIX_NNZ": 25000, "MATRIX_DENSITY": 0.001, "TIME_S": 9.927400827407837}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 7, 17, ..., 24988, 24992, 25000]),
col_indices=tensor([1765, 1880, 2380, ..., 3402, 4335, 4928]),
values=tensor([0.8113, 0.6065, 0.0419, ..., 0.8515, 0.2786, 0.9879]),
size=(5000, 5000), nnz=25000, layout=torch.sparse_csr)
tensor([0.6729, 0.2847, 0.7618, ..., 0.5837, 0.8359, 0.7138])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([5000, 5000])
Rows: 5000
Size: 25000000
NNZ: 25000
Density: 0.001
Time: 9.927400827407837 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 17852 -ss 5000 -sd 0.001 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [5000, 5000], "MATRIX_ROWS": 5000, "MATRIX_SIZE": 25000000, "MATRIX_NNZ": 25000, "MATRIX_DENSITY": 0.001, "TIME_S": 10.54783010482788}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 5, 10, ..., 24988, 24991, 25000]),
col_indices=tensor([ 732, 2237, 2424, ..., 1459, 1662, 4133]),
values=tensor([0.5131, 0.9715, 0.7721, ..., 0.9714, 0.5730, 0.7149]),
size=(5000, 5000), nnz=25000, layout=torch.sparse_csr)
tensor([0.7581, 0.5458, 0.9932, ..., 0.3205, 0.5744, 0.9847])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([5000, 5000])
Rows: 5000
Size: 25000000
NNZ: 25000
Density: 0.001
Time: 10.54783010482788 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 5, 10, ..., 24988, 24991, 25000]),
col_indices=tensor([ 732, 2237, 2424, ..., 1459, 1662, 4133]),
values=tensor([0.5131, 0.9715, 0.7721, ..., 0.9714, 0.5730, 0.7149]),
size=(5000, 5000), nnz=25000, layout=torch.sparse_csr)
tensor([0.7581, 0.5458, 0.9932, ..., 0.3205, 0.5744, 0.9847])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([5000, 5000])
Rows: 5000
Size: 25000000
NNZ: 25000
Density: 0.001
Time: 10.54783010482788 seconds
[16.36, 16.36, 16.32, 16.6, 16.8, 17.04, 17.2, 17.08, 16.8, 16.52]
[16.48, 16.4, 17.36, 19.52, 19.52, 21.32, 21.84, 22.56, 21.0, 20.28, 19.68, 19.84, 19.92, 19.92]
14.188893795013428
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 17852, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [5000, 5000], 'MATRIX_ROWS': 5000, 'MATRIX_SIZE': 25000000, 'MATRIX_NNZ': 25000, 'MATRIX_DENSITY': 0.001, 'TIME_S': 10.54783010482788, 'TIME_S_1KI': 0.5908486502816425, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 261.2027643966674, 'W': 18.408959018952206}
[16.36, 16.36, 16.32, 16.6, 16.8, 17.04, 17.2, 17.08, 16.8, 16.52, 16.4, 16.36, 16.32, 16.32, 16.76, 16.96, 16.72, 16.44, 16.2, 16.2]
299.02
14.950999999999999
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 17852, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [5000, 5000], 'MATRIX_ROWS': 5000, 'MATRIX_SIZE': 25000000, 'MATRIX_NNZ': 25000, 'MATRIX_DENSITY': 0.001, 'TIME_S': 10.54783010482788, 'TIME_S_1KI': 0.5908486502816425, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 261.2027643966674, 'W': 18.408959018952206, 'J_1KI': 14.6315686979984, 'W_1KI': 1.0311986902841253, 'W_D': 3.4579590189522076, 'J_D': 49.0646132674217, 'W_D_1KI': 0.19370149109075777, 'J_D_1KI': 0.010850408418707023}

1
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_5000_0.01.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Altra", "CORES": 16, "ITERATIONS": 1933, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [5000, 5000], "MATRIX_ROWS": 5000, "MATRIX_SIZE": 25000000, "MATRIX_NNZ": 250000, "MATRIX_DENSITY": 0.01, "TIME_S": 10.477078676223755, "TIME_S_1KI": 5.420113127896407, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 268.2967868804932, "W": 18.818848497168876, "J_1KI": 138.79813082281075, "W_1KI": 9.7355656995183, "W_D": 3.947848497168877, "J_D": 56.283734206199696, "W_D_1KI": 2.0423427300408057, "J_D_1KI": 1.0565663373206444}

65
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_5000_0.01.output Normal file
View File

@ -0,0 +1,65 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 1000 -ss 5000 -sd 0.01 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [5000, 5000], "MATRIX_ROWS": 5000, "MATRIX_SIZE": 25000000, "MATRIX_NNZ": 250000, "MATRIX_DENSITY": 0.01, "TIME_S": 5.431562900543213}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 36, 79, ..., 249900, 249941,
250000]),
col_indices=tensor([ 80, 388, 404, ..., 4737, 4807, 4857]),
values=tensor([0.4885, 0.5213, 0.1721, ..., 0.5810, 0.1625, 0.7107]),
size=(5000, 5000), nnz=250000, layout=torch.sparse_csr)
tensor([0.1545, 0.4718, 0.9539, ..., 0.2261, 0.6017, 0.7355])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([5000, 5000])
Rows: 5000
Size: 25000000
NNZ: 250000
Density: 0.01
Time: 5.431562900543213 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 1933 -ss 5000 -sd 0.01 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [5000, 5000], "MATRIX_ROWS": 5000, "MATRIX_SIZE": 25000000, "MATRIX_NNZ": 250000, "MATRIX_DENSITY": 0.01, "TIME_S": 10.477078676223755}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 40, 89, ..., 249917, 249964,
250000]),
col_indices=tensor([ 165, 177, 195, ..., 4656, 4719, 4927]),
values=tensor([0.2100, 0.9405, 0.2582, ..., 0.7931, 0.5258, 0.8197]),
size=(5000, 5000), nnz=250000, layout=torch.sparse_csr)
tensor([0.9173, 0.2185, 0.4076, ..., 0.3362, 0.1795, 0.2923])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([5000, 5000])
Rows: 5000
Size: 25000000
NNZ: 250000
Density: 0.01
Time: 10.477078676223755 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 40, 89, ..., 249917, 249964,
250000]),
col_indices=tensor([ 165, 177, 195, ..., 4656, 4719, 4927]),
values=tensor([0.2100, 0.9405, 0.2582, ..., 0.7931, 0.5258, 0.8197]),
size=(5000, 5000), nnz=250000, layout=torch.sparse_csr)
tensor([0.9173, 0.2185, 0.4076, ..., 0.3362, 0.1795, 0.2923])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([5000, 5000])
Rows: 5000
Size: 25000000
NNZ: 250000
Density: 0.01
Time: 10.477078676223755 seconds
[17.04, 17.04, 16.96, 17.04, 16.64, 16.4, 16.44, 16.32, 16.24, 16.36]
[16.44, 16.52, 17.76, 19.52, 21.52, 21.52, 22.36, 22.76, 21.68, 21.36, 19.84, 20.04, 20.0, 20.08]
14.25681209564209
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 1933, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [5000, 5000], 'MATRIX_ROWS': 5000, 'MATRIX_SIZE': 25000000, 'MATRIX_NNZ': 250000, 'MATRIX_DENSITY': 0.01, 'TIME_S': 10.477078676223755, 'TIME_S_1KI': 5.420113127896407, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 268.2967868804932, 'W': 18.818848497168876}
[17.04, 17.04, 16.96, 17.04, 16.64, 16.4, 16.44, 16.32, 16.24, 16.36, 16.4, 16.24, 16.32, 16.36, 16.36, 16.48, 16.68, 16.56, 16.4, 16.08]
297.41999999999996
14.870999999999999
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 1933, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [5000, 5000], 'MATRIX_ROWS': 5000, 'MATRIX_SIZE': 25000000, 'MATRIX_NNZ': 250000, 'MATRIX_DENSITY': 0.01, 'TIME_S': 10.477078676223755, 'TIME_S_1KI': 5.420113127896407, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 268.2967868804932, 'W': 18.818848497168876, 'J_1KI': 138.79813082281075, 'W_1KI': 9.7355656995183, 'W_D': 3.947848497168877, 'J_D': 56.283734206199696, 'W_D_1KI': 2.0423427300408057, 'J_D_1KI': 1.0565663373206444}

1
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_5000_0.05.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Altra", "CORES": 16, "ITERATIONS": 1000, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [5000, 5000], "MATRIX_ROWS": 5000, "MATRIX_SIZE": 25000000, "MATRIX_NNZ": 1250000, "MATRIX_DENSITY": 0.05, "TIME_S": 26.830852508544922, "TIME_S_1KI": 26.830852508544922, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 724.3529372215271, "W": 23.831275335163394, "J_1KI": 724.3529372215271, "W_1KI": 23.831275335163394, "W_D": 5.2862753351633955, "J_D": 160.67663237214092, "W_D_1KI": 5.2862753351633955, "J_D_1KI": 5.2862753351633955}

45
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_5000_0.05.output Normal file
View File

@ -0,0 +1,45 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 1000 -ss 5000 -sd 0.05 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [5000, 5000], "MATRIX_ROWS": 5000, "MATRIX_SIZE": 25000000, "MATRIX_NNZ": 1250000, "MATRIX_DENSITY": 0.05, "TIME_S": 26.830852508544922}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 229, 490, ..., 1249494,
1249740, 1250000]),
col_indices=tensor([ 18, 28, 58, ..., 4928, 4934, 4938]),
values=tensor([0.5574, 0.5312, 0.0435, ..., 0.2785, 0.4540, 0.5116]),
size=(5000, 5000), nnz=1250000, layout=torch.sparse_csr)
tensor([0.0667, 0.4882, 0.3630, ..., 0.8923, 0.8020, 0.4280])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([5000, 5000])
Rows: 5000
Size: 25000000
NNZ: 1250000
Density: 0.05
Time: 26.830852508544922 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 229, 490, ..., 1249494,
1249740, 1250000]),
col_indices=tensor([ 18, 28, 58, ..., 4928, 4934, 4938]),
values=tensor([0.5574, 0.5312, 0.0435, ..., 0.2785, 0.4540, 0.5116]),
size=(5000, 5000), nnz=1250000, layout=torch.sparse_csr)
tensor([0.0667, 0.4882, 0.3630, ..., 0.8923, 0.8020, 0.4280])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([5000, 5000])
Rows: 5000
Size: 25000000
NNZ: 1250000
Density: 0.05
Time: 26.830852508544922 seconds
[20.52, 20.64, 20.8, 20.76, 20.84, 20.84, 20.8, 20.88, 20.8, 20.88]
[20.64, 20.72, 20.92, 24.36, 26.68, 28.84, 29.6, 27.08, 27.08, 26.84, 23.8, 24.0, 24.32, 24.44, 24.48, 24.52, 24.36, 24.12, 24.24, 24.2, 24.2, 24.28, 24.28, 24.28, 24.2, 24.28, 24.16, 24.12, 24.08, 24.08]
30.395055532455444
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 1000, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [5000, 5000], 'MATRIX_ROWS': 5000, 'MATRIX_SIZE': 25000000, 'MATRIX_NNZ': 1250000, 'MATRIX_DENSITY': 0.05, 'TIME_S': 26.830852508544922, 'TIME_S_1KI': 26.830852508544922, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 724.3529372215271, 'W': 23.831275335163394}
[20.52, 20.64, 20.8, 20.76, 20.84, 20.84, 20.8, 20.88, 20.8, 20.88, 20.44, 20.56, 20.56, 20.6, 20.6, 20.48, 20.32, 20.2, 20.2, 20.2]
370.9
18.544999999999998
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 1000, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [5000, 5000], 'MATRIX_ROWS': 5000, 'MATRIX_SIZE': 25000000, 'MATRIX_NNZ': 1250000, 'MATRIX_DENSITY': 0.05, 'TIME_S': 26.830852508544922, 'TIME_S_1KI': 26.830852508544922, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 724.3529372215271, 'W': 23.831275335163394, 'J_1KI': 724.3529372215271, 'W_1KI': 23.831275335163394, 'W_D': 5.2862753351633955, 'J_D': 160.67663237214092, 'W_D_1KI': 5.2862753351633955, 'J_D_1KI': 5.2862753351633955}

1
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_5000_0.1.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Altra", "CORES": 16, "ITERATIONS": 1000, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [5000, 5000], "MATRIX_ROWS": 5000, "MATRIX_SIZE": 25000000, "MATRIX_NNZ": 2500000, "MATRIX_DENSITY": 0.1, "TIME_S": 52.60684037208557, "TIME_S_1KI": 52.60684037208557, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 1396.747187700272, "W": 24.19749919495284, "J_1KI": 1396.747187700272, "W_1KI": 24.19749919495284, "W_D": 5.574499194952839, "J_D": 321.77565171742464, "W_D_1KI": 5.574499194952839, "J_D_1KI": 5.574499194952839}

45
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_5000_0.1.output Normal file
View File

@ -0,0 +1,45 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 1000 -ss 5000 -sd 0.1 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [5000, 5000], "MATRIX_ROWS": 5000, "MATRIX_SIZE": 25000000, "MATRIX_NNZ": 2500000, "MATRIX_DENSITY": 0.1, "TIME_S": 52.60684037208557}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 495, 1009, ..., 2499036,
2499501, 2500000]),
col_indices=tensor([ 3, 5, 7, ..., 4975, 4989, 4996]),
values=tensor([0.3153, 0.9204, 0.9402, ..., 0.8644, 0.1243, 0.2567]),
size=(5000, 5000), nnz=2500000, layout=torch.sparse_csr)
tensor([0.0882, 0.6551, 0.2953, ..., 0.5102, 0.2382, 0.8339])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([5000, 5000])
Rows: 5000
Size: 25000000
NNZ: 2500000
Density: 0.1
Time: 52.60684037208557 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 495, 1009, ..., 2499036,
2499501, 2500000]),
col_indices=tensor([ 3, 5, 7, ..., 4975, 4989, 4996]),
values=tensor([0.3153, 0.9204, 0.9402, ..., 0.8644, 0.1243, 0.2567]),
size=(5000, 5000), nnz=2500000, layout=torch.sparse_csr)
tensor([0.0882, 0.6551, 0.2953, ..., 0.5102, 0.2382, 0.8339])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([5000, 5000])
Rows: 5000
Size: 25000000
NNZ: 2500000
Density: 0.1
Time: 52.60684037208557 seconds
[20.32, 20.32, 20.52, 20.36, 20.68, 20.64, 20.64, 20.84, 20.84, 20.64]
[21.04, 20.8, 23.84, 25.56, 28.32, 28.32, 30.0, 30.76, 27.04, 26.12, 23.96, 24.04, 23.96, 24.4, 24.48, 24.44, 24.4, 24.4, 24.4, 24.44, 24.52, 24.64, 24.44, 24.48, 24.36, 24.52, 24.36, 24.36, 24.28, 24.28, 24.2, 24.2, 24.04, 24.12, 24.04, 24.04, 24.08, 24.16, 24.12, 23.96, 24.0, 24.04, 24.04, 23.92, 23.92, 24.16, 24.32, 24.52, 24.68, 24.64, 24.24, 24.12, 24.2, 24.2, 24.2, 24.36, 24.36]
57.72279095649719
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 1000, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [5000, 5000], 'MATRIX_ROWS': 5000, 'MATRIX_SIZE': 25000000, 'MATRIX_NNZ': 2500000, 'MATRIX_DENSITY': 0.1, 'TIME_S': 52.60684037208557, 'TIME_S_1KI': 52.60684037208557, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 1396.747187700272, 'W': 24.19749919495284}
[20.32, 20.32, 20.52, 20.36, 20.68, 20.64, 20.64, 20.84, 20.84, 20.64, 20.48, 20.4, 20.44, 20.76, 20.76, 20.96, 21.12, 21.08, 21.0, 20.76]
372.46000000000004
18.623
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 1000, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [5000, 5000], 'MATRIX_ROWS': 5000, 'MATRIX_SIZE': 25000000, 'MATRIX_NNZ': 2500000, 'MATRIX_DENSITY': 0.1, 'TIME_S': 52.60684037208557, 'TIME_S_1KI': 52.60684037208557, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 1396.747187700272, 'W': 24.19749919495284, 'J_1KI': 1396.747187700272, 'W_1KI': 24.19749919495284, 'W_D': 5.574499194952839, 'J_D': 321.77565171742464, 'W_D_1KI': 5.574499194952839, 'J_D_1KI': 5.574499194952839}

1
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_5000_0.2.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Altra", "CORES": 16, "ITERATIONS": 1000, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [5000, 5000], "MATRIX_ROWS": 5000, "MATRIX_SIZE": 25000000, "MATRIX_NNZ": 5000000, "MATRIX_DENSITY": 0.2, "TIME_S": 105.2479407787323, "TIME_S_1KI": 105.2479407787323, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 2877.626370677949, "W": 24.097306664358964, "J_1KI": 2877.626370677949, "W_1KI": 24.097306664358964, "W_D": 5.6223066643589625, "J_D": 671.3985984718811, "W_D_1KI": 5.6223066643589625, "J_D_1KI": 5.6223066643589625}

45
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_5000_0.2.output Normal file
View File

@ -0,0 +1,45 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 1000 -ss 5000 -sd 0.2 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [5000, 5000], "MATRIX_ROWS": 5000, "MATRIX_SIZE": 25000000, "MATRIX_NNZ": 5000000, "MATRIX_DENSITY": 0.2, "TIME_S": 105.2479407787323}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 987, 1961, ..., 4998062,
4998993, 5000000]),
col_indices=tensor([ 2, 8, 14, ..., 4993, 4994, 4998]),
values=tensor([0.2058, 0.7964, 0.8021, ..., 0.0689, 0.5253, 0.0161]),
size=(5000, 5000), nnz=5000000, layout=torch.sparse_csr)
tensor([0.1259, 0.8957, 0.2222, ..., 0.6970, 0.5570, 0.6933])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([5000, 5000])
Rows: 5000
Size: 25000000
NNZ: 5000000
Density: 0.2
Time: 105.2479407787323 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 987, 1961, ..., 4998062,
4998993, 5000000]),
col_indices=tensor([ 2, 8, 14, ..., 4993, 4994, 4998]),
values=tensor([0.2058, 0.7964, 0.8021, ..., 0.0689, 0.5253, 0.0161]),
size=(5000, 5000), nnz=5000000, layout=torch.sparse_csr)
tensor([0.1259, 0.8957, 0.2222, ..., 0.6970, 0.5570, 0.6933])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([5000, 5000])
Rows: 5000
Size: 25000000
NNZ: 5000000
Density: 0.2
Time: 105.2479407787323 seconds
[20.6, 20.48, 20.6, 20.6, 20.72, 20.72, 20.68, 20.68, 20.52, 20.76]
[20.8, 20.6, 20.6, 24.4, 25.4, 28.96, 30.96, 31.56, 28.6, 27.8, 25.4, 24.24, 24.24, 24.24, 24.24, 24.24, 24.16, 24.04, 24.12, 24.2, 24.2, 24.28, 24.36, 24.2, 24.32, 24.4, 24.56, 24.56, 24.56, 24.44, 24.44, 24.24, 24.2, 24.16, 24.04, 24.32, 24.24, 24.32, 24.4, 24.4, 24.36, 24.4, 24.6, 24.8, 24.72, 24.88, 24.88, 24.64, 24.48, 24.48, 24.2, 24.12, 24.12, 24.28, 24.48, 24.56, 24.56, 24.6, 24.28, 24.16, 24.16, 24.04, 24.08, 24.24, 24.24, 24.64, 24.72, 24.6, 24.48, 24.12, 24.16, 24.08, 24.16, 24.2, 23.84, 23.92, 23.92, 23.92, 23.76, 24.2, 24.16, 24.28, 24.64, 24.44, 24.36, 24.52, 24.36, 24.4, 24.48, 24.48, 24.56, 24.56, 24.56, 24.36, 24.36, 24.2, 24.32, 24.08, 24.16, 24.24, 24.4, 24.4, 24.44, 24.68, 24.56, 24.4, 24.28, 24.4, 24.32, 24.4, 24.6, 24.48, 24.44, 24.6, 24.6, 24.48, 24.28, 24.24]
119.4169294834137
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 1000, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [5000, 5000], 'MATRIX_ROWS': 5000, 'MATRIX_SIZE': 25000000, 'MATRIX_NNZ': 5000000, 'MATRIX_DENSITY': 0.2, 'TIME_S': 105.2479407787323, 'TIME_S_1KI': 105.2479407787323, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 2877.626370677949, 'W': 24.097306664358964}
[20.6, 20.48, 20.6, 20.6, 20.72, 20.72, 20.68, 20.68, 20.52, 20.76, 20.2, 20.32, 20.2, 20.12, 20.32, 20.24, 20.6, 20.72, 20.8, 20.8]
369.5
18.475
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 1000, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [5000, 5000], 'MATRIX_ROWS': 5000, 'MATRIX_SIZE': 25000000, 'MATRIX_NNZ': 5000000, 'MATRIX_DENSITY': 0.2, 'TIME_S': 105.2479407787323, 'TIME_S_1KI': 105.2479407787323, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 2877.626370677949, 'W': 24.097306664358964, 'J_1KI': 2877.626370677949, 'W_1KI': 24.097306664358964, 'W_D': 5.6223066643589625, 'J_D': 671.3985984718811, 'W_D_1KI': 5.6223066643589625, 'J_D_1KI': 5.6223066643589625}

1
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_5000_0.3.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Altra", "CORES": 16, "ITERATIONS": 1000, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [5000, 5000], "MATRIX_ROWS": 5000, "MATRIX_SIZE": 25000000, "MATRIX_NNZ": 7500000, "MATRIX_DENSITY": 0.3, "TIME_S": 171.51510739326477, "TIME_S_1KI": 171.51510739326477, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 4017.952876434326, "W": 24.359705854077962, "J_1KI": 4017.9528764343263, "W_1KI": 24.359705854077962, "W_D": 5.79370585407796, "J_D": 955.6288257770532, "W_D_1KI": 5.79370585407796, "J_D_1KI": 5.79370585407796}

45
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_5000_0.3.output Normal file
View File

@ -0,0 +1,45 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 1000 -ss 5000 -sd 0.3 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [5000, 5000], "MATRIX_ROWS": 5000, "MATRIX_SIZE": 25000000, "MATRIX_NNZ": 7500000, "MATRIX_DENSITY": 0.3, "TIME_S": 171.51510739326477}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 1461, 2933, ..., 7497082,
7498527, 7500000]),
col_indices=tensor([ 0, 1, 3, ..., 4992, 4997, 4999]),
values=tensor([0.2348, 0.4295, 0.7390, ..., 0.0266, 0.0621, 0.6356]),
size=(5000, 5000), nnz=7500000, layout=torch.sparse_csr)
tensor([0.3584, 0.9157, 0.1902, ..., 0.2272, 0.0135, 0.3908])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([5000, 5000])
Rows: 5000
Size: 25000000
NNZ: 7500000
Density: 0.3
Time: 171.51510739326477 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 1461, 2933, ..., 7497082,
7498527, 7500000]),
col_indices=tensor([ 0, 1, 3, ..., 4992, 4997, 4999]),
values=tensor([0.2348, 0.4295, 0.7390, ..., 0.0266, 0.0621, 0.6356]),
size=(5000, 5000), nnz=7500000, layout=torch.sparse_csr)
tensor([0.3584, 0.9157, 0.1902, ..., 0.2272, 0.0135, 0.3908])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([5000, 5000])
Rows: 5000
Size: 25000000
NNZ: 7500000
Density: 0.3
Time: 171.51510739326477 seconds
[21.16, 20.96, 20.88, 20.76, 20.72, 20.72, 20.72, 20.6, 20.56, 20.56]
[20.6, 20.48, 20.88, 21.96, 23.44, 26.4, 27.84, 28.8, 28.48, 27.04, 25.6, 24.28, 24.28, 24.48, 24.64, 24.64, 24.6, 24.6, 24.4, 24.24, 24.36, 24.48, 24.44, 24.52, 24.6, 24.6, 24.96, 25.04, 25.04, 25.12, 24.68, 24.56, 24.64, 24.6, 24.68, 24.92, 24.84, 24.84, 24.56, 24.48, 24.8, 24.56, 24.76, 24.76, 24.68, 24.64, 24.72, 24.64, 24.6, 24.6, 24.68, 24.68, 24.56, 24.48, 24.6, 24.48, 24.48, 24.56, 24.64, 24.52, 24.48, 24.6, 24.6, 24.52, 24.24, 24.32, 24.44, 24.32, 24.44, 24.44, 24.64, 24.84, 24.6, 24.76, 24.76, 24.8, 24.92, 25.08, 25.04, 24.92, 24.52, 24.6, 24.56, 24.6, 24.48, 24.6, 24.56, 24.56, 24.4, 24.36, 24.48, 24.48, 24.64, 24.64, 24.52, 24.56, 24.52, 24.44, 24.52, 24.52, 24.52, 24.48, 24.32, 24.52, 24.84, 25.04, 25.04, 25.0, 24.92, 24.68, 24.36, 24.36, 24.36, 24.24, 24.36, 24.36, 24.8, 24.72, 24.84, 24.68, 24.44, 24.56, 24.64, 24.72, 24.72, 25.16, 25.56, 25.68, 25.56, 25.36, 24.88, 24.8, 24.72, 24.52, 24.48, 24.6, 24.6, 24.6, 24.44, 24.44, 24.36, 24.44, 24.56, 24.56, 24.76, 24.64, 24.48, 24.72, 24.72, 24.72, 24.56, 24.92, 24.8, 24.56, 24.72, 24.8, 24.88, 24.88, 24.96, 24.84, 24.6, 24.6, 24.16]
164.9425859451294
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 1000, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [5000, 5000], 'MATRIX_ROWS': 5000, 'MATRIX_SIZE': 25000000, 'MATRIX_NNZ': 7500000, 'MATRIX_DENSITY': 0.3, 'TIME_S': 171.51510739326477, 'TIME_S_1KI': 171.51510739326477, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 4017.952876434326, 'W': 24.359705854077962}
[21.16, 20.96, 20.88, 20.76, 20.72, 20.72, 20.72, 20.6, 20.56, 20.56, 20.0, 20.24, 20.64, 20.6, 20.8, 20.76, 20.44, 20.48, 20.4, 20.36]
371.32000000000005
18.566000000000003
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 1000, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [5000, 5000], 'MATRIX_ROWS': 5000, 'MATRIX_SIZE': 25000000, 'MATRIX_NNZ': 7500000, 'MATRIX_DENSITY': 0.3, 'TIME_S': 171.51510739326477, 'TIME_S_1KI': 171.51510739326477, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 4017.952876434326, 'W': 24.359705854077962, 'J_1KI': 4017.9528764343263, 'W_1KI': 24.359705854077962, 'W_D': 5.79370585407796, 'J_D': 955.6288257770532, 'W_D_1KI': 5.79370585407796, 'J_D_1KI': 5.79370585407796}

1
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_5000_1e-05.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Altra", "CORES": 16, "ITERATIONS": 293134, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [5000, 5000], "MATRIX_ROWS": 5000, "MATRIX_SIZE": 25000000, "MATRIX_NNZ": 250, "MATRIX_DENSITY": 1e-05, "TIME_S": 10.89356017112732, "TIME_S_1KI": 0.03716239048055606, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 278.4485914421082, "W": 19.57952781791354, "J_1KI": 0.9499020633638819, "W_1KI": 0.06679377969772711, "W_D": 4.613527817913537, "J_D": 65.610893910408, "W_D_1KI": 0.01573863085794735, "J_D_1KI": 5.3690908792386244e-05}

437
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_5000_1e-05.output Normal file
View File

@ -0,0 +1,437 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 1000 -ss 5000 -sd 1e-05 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [5000, 5000], "MATRIX_ROWS": 5000, "MATRIX_SIZE": 25000000, "MATRIX_NNZ": 250, "MATRIX_DENSITY": 1e-05, "TIME_S": 0.04628562927246094}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 0, 0, ..., 250, 250, 250]),
col_indices=tensor([ 683, 1119, 1321, 2450, 3482, 3631, 1761, 3022, 756,
3517, 37, 3468, 4655, 1287, 913, 1692, 3561, 1823,
1971, 4332, 175, 242, 3518, 2634, 2163, 1929, 1347,
4194, 4673, 3242, 1554, 3336, 2363, 4819, 1624, 2276,
4446, 1440, 2278, 2820, 2808, 2194, 1293, 3294, 2532,
2630, 3533, 2517, 2068, 4492, 3196, 31, 2012, 3028,
3263, 1298, 1827, 4518, 2739, 383, 2502, 2163, 2983,
275, 3460, 724, 4585, 3927, 4513, 2645, 242, 1435,
3115, 1351, 1335, 3004, 3671, 2087, 2361, 3470, 3033,
1776, 2762, 2985, 544, 2787, 1009, 4955, 757, 4621,
3559, 4933, 3451, 2535, 2363, 1115, 250, 284, 3453,
4194, 4788, 4427, 434, 2792, 219, 1976, 286, 1619,
3123, 2185, 100, 1443, 2614, 3193, 4750, 1625, 61,
2975, 2813, 3271, 969, 1209, 2770, 2904, 1769, 343,
239, 3167, 403, 2400, 1507, 4176, 1210, 627, 332,
3526, 2019, 4707, 4667, 3689, 1411, 474, 2037, 1559,
3233, 2371, 3442, 4237, 1757, 4685, 2495, 737, 562,
4385, 4537, 1150, 2708, 4099, 4510, 4059, 58, 3153,
2292, 1450, 3200, 4511, 1556, 237, 2082, 3442, 4661,
3624, 407, 1680, 104, 2285, 3192, 1818, 2013, 2874,
4274, 1703, 393, 4638, 3642, 1595, 4200, 2976, 747,
1685, 436, 4175, 3319, 2858, 4687, 1967, 1550, 4498,
5, 3295, 2892, 3076, 2947, 1470, 2928, 4594, 372,
1505, 3795, 2014, 3988, 420, 2057, 4772, 3022, 3131,
376, 1473, 4703, 771, 759, 172, 3505, 2361, 168,
3559, 881, 3500, 894, 4238, 842, 291, 2606, 4128,
2513, 4919, 1689, 1039, 4346, 4963, 184, 2438, 3794,
631, 3050, 4745, 3174, 1910, 3181, 4415]),
values=tensor([0.5133, 0.9500, 0.6089, 0.1299, 0.0389, 0.7021, 0.0545,
0.1504, 0.2775, 0.3654, 0.5414, 0.7066, 0.5062, 0.9276,
0.5403, 0.1473, 0.0619, 0.8013, 0.5229, 0.9618, 0.3595,
0.9768, 0.4894, 0.9436, 0.2586, 0.3228, 0.7550, 0.4654,
0.5557, 0.6099, 0.1466, 0.3234, 0.9559, 0.4861, 0.6590,
0.2645, 0.3128, 0.2881, 0.8916, 0.9625, 0.3287, 0.6208,
0.1989, 0.4749, 0.6654, 0.5023, 0.5464, 0.6484, 0.8692,
0.5946, 0.3095, 0.4520, 0.2934, 0.1142, 0.3825, 0.0692,
0.4451, 0.9095, 0.2024, 0.8392, 0.4692, 0.1054, 0.2753,
0.1688, 0.2684, 0.5848, 0.9464, 0.6200, 0.5357, 0.5307,
0.7002, 0.6351, 0.9452, 0.4196, 0.3107, 0.9700, 0.4879,
0.0926, 0.0442, 0.1064, 0.9432, 0.8436, 0.3680, 0.1497,
0.1266, 0.6045, 0.6916, 0.0824, 0.1706, 0.8211, 0.8262,
0.7835, 0.0310, 0.3323, 0.1890, 0.5250, 0.8324, 0.5975,
0.0174, 0.0556, 0.9553, 0.6279, 0.3153, 0.4085, 0.9318,
0.3588, 0.1032, 0.7200, 0.2145, 0.8631, 0.4178, 0.0372,
0.7636, 0.4317, 0.2105, 0.2684, 0.0231, 0.6996, 0.0880,
0.2381, 0.6281, 0.3203, 0.4143, 0.7477, 0.1347, 0.5900,
0.7586, 0.5291, 0.6348, 0.4495, 0.3601, 0.9398, 0.3999,
0.2033, 0.1346, 0.0706, 0.9911, 0.9515, 0.0420, 0.6637,
0.2691, 0.3435, 0.7224, 0.4624, 0.4390, 0.3084, 0.3677,
0.2556, 0.8927, 0.7015, 0.4402, 0.6275, 0.9141, 0.3633,
0.0870, 0.2460, 0.1945, 0.8036, 0.3884, 0.5353, 0.6776,
0.4646, 0.1680, 0.4783, 0.9893, 0.5596, 0.0460, 0.9167,
0.8564, 0.2217, 0.2454, 0.6476, 0.0091, 0.6634, 0.6906,
0.5109, 0.0619, 0.8391, 0.3721, 0.4015, 0.1086, 0.8568,
0.0263, 0.0960, 0.2106, 0.8204, 0.3496, 0.0650, 0.0530,
0.2300, 0.7920, 0.0833, 0.8839, 0.6947, 0.7490, 0.6930,
0.4034, 0.9770, 0.5568, 0.5813, 0.4457, 0.4409, 0.3165,
0.4290, 0.8018, 0.4890, 0.7248, 0.5066, 0.4197, 0.9251,
0.4526, 0.8257, 0.6029, 0.9210, 0.8099, 0.1966, 0.6605,
0.5583, 0.0851, 0.2553, 0.8703, 0.6237, 0.8267, 0.9769,
0.6623, 0.5390, 0.0172, 0.1684, 0.4788, 0.5289, 0.0477,
0.8018, 0.0914, 0.3275, 0.7127, 0.1031, 0.8096, 0.1163,
0.3143, 0.8185, 0.2797, 0.8908, 0.1307, 0.5822, 0.2044,
0.6227, 0.4853, 0.6034, 0.6732, 0.0321]),
size=(5000, 5000), nnz=250, layout=torch.sparse_csr)
tensor([0.7002, 0.3467, 0.9676, ..., 0.8135, 0.6463, 0.9360])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([5000, 5000])
Rows: 5000
Size: 25000000
NNZ: 250
Density: 1e-05
Time: 0.04628562927246094 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 226852 -ss 5000 -sd 1e-05 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [5000, 5000], "MATRIX_ROWS": 5000, "MATRIX_SIZE": 25000000, "MATRIX_NNZ": 250, "MATRIX_DENSITY": 1e-05, "TIME_S": 8.58342981338501}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 1, 1, ..., 250, 250, 250]),
col_indices=tensor([2568, 3647, 442, 965, 263, 2383, 651, 4423, 3036,
1922, 4223, 1539, 1097, 1063, 4112, 2393, 2048, 391,
3893, 324, 2099, 2458, 2688, 682, 96, 2079, 4917,
1561, 2320, 1455, 2135, 3126, 2991, 4240, 1021, 4993,
3258, 3975, 1172, 1489, 4782, 364, 2199, 94, 1257,
4686, 607, 1510, 89, 4888, 4165, 3842, 3018, 4662,
3670, 3231, 4131, 746, 49, 680, 3901, 1594, 359,
3311, 2321, 3005, 4317, 2855, 829, 3097, 2418, 1365,
3858, 1930, 3446, 1588, 4464, 2454, 3676, 2837, 1569,
2885, 1556, 3076, 4363, 2721, 3030, 172, 2121, 2698,
3156, 442, 947, 2541, 828, 1038, 4897, 3795, 2214,
609, 3658, 77, 3238, 2356, 89, 2253, 2806, 2065,
2259, 579, 2660, 1688, 2237, 2605, 1390, 4025, 2509,
2831, 635, 2338, 2347, 3405, 393, 82, 2030, 4203,
4365, 3211, 1439, 3151, 1397, 476, 3123, 1758, 2491,
252, 1078, 102, 4624, 527, 163, 2201, 1415, 53,
3597, 2281, 1819, 1693, 3944, 4697, 560, 1457, 1677,
2072, 2996, 1150, 4324, 2498, 4491, 2244, 3104, 2934,
632, 2182, 4187, 1162, 422, 1444, 3294, 1160, 1691,
2846, 266, 3519, 3656, 2923, 1457, 1651, 1147, 1014,
671, 3331, 4535, 2766, 1343, 680, 3907, 3255, 700,
2823, 4644, 4966, 3493, 4426, 2084, 2312, 2388, 1167,
2294, 2501, 1866, 3421, 4059, 858, 4657, 794, 658,
2225, 1411, 1995, 2476, 795, 2719, 1100, 685, 3038,
1607, 4350, 2782, 410, 2489, 2516, 1183, 2789, 4067,
4708, 2699, 3392, 4757, 4834, 2136, 1271, 2790, 3056,
2835, 3630, 2085, 603, 3829, 4234, 710, 378, 2071,
1558, 4206, 4361, 1063, 3780, 352, 168]),
values=tensor([6.8562e-01, 9.9314e-01, 3.4074e-01, 1.7233e-01,
1.4522e-02, 6.3720e-01, 5.5464e-02, 7.3826e-01,
1.5940e-01, 1.2632e-01, 2.2414e-01, 7.6966e-01,
6.9475e-01, 9.2958e-01, 3.8229e-01, 7.5368e-01,
7.6972e-01, 6.6374e-01, 5.6166e-01, 6.7113e-01,
2.6640e-01, 3.1404e-01, 8.1747e-01, 7.0390e-01,
3.3211e-02, 4.2381e-01, 1.8457e-01, 3.9280e-01,
7.9738e-01, 4.8542e-01, 5.6000e-01, 2.0755e-01,
7.0598e-01, 8.6707e-01, 1.7337e-01, 7.0748e-01,
9.7389e-01, 7.9562e-01, 6.7701e-01, 4.6490e-01,
5.4665e-01, 4.9560e-02, 5.8946e-01, 3.8658e-01,
3.0672e-01, 2.5947e-01, 8.6455e-01, 8.5056e-02,
3.3869e-01, 3.9093e-01, 5.9721e-01, 6.2207e-01,
8.8265e-01, 8.1640e-01, 1.7680e-01, 2.4072e-01,
3.6980e-01, 2.2490e-01, 6.0225e-01, 7.0554e-01,
8.5790e-01, 7.4936e-01, 1.7010e-01, 2.0063e-01,
1.1246e-01, 6.8727e-01, 6.8037e-01, 8.9757e-01,
3.8505e-01, 6.5721e-01, 9.3013e-01, 4.9507e-01,
7.9582e-01, 3.6413e-01, 6.2028e-01, 2.8858e-01,
2.8115e-01, 4.5974e-01, 9.8822e-01, 1.1635e-01,
5.8307e-01, 5.1420e-02, 1.1202e-01, 5.4531e-01,
7.6023e-01, 9.0514e-01, 5.3398e-01, 1.7667e-01,
9.2343e-01, 9.0805e-01, 9.6041e-01, 5.0364e-01,
2.4720e-01, 1.5194e-01, 2.2205e-01, 3.0452e-01,
6.8304e-02, 7.0941e-02, 2.3679e-01, 2.9428e-01,
2.6988e-01, 2.9905e-01, 9.7067e-01, 3.9498e-01,
4.5558e-01, 6.9955e-01, 5.3969e-02, 3.5860e-01,
7.2397e-01, 7.1675e-01, 8.0095e-01, 4.8315e-01,
4.1035e-01, 3.9824e-01, 5.0060e-01, 5.6947e-01,
2.5338e-01, 1.2799e-01, 9.1108e-01, 7.6016e-02,
8.5394e-01, 4.5257e-01, 4.8350e-01, 1.3291e-01,
2.2106e-01, 8.0845e-01, 6.7657e-01, 4.4898e-01,
6.6830e-01, 4.0859e-01, 8.4227e-01, 7.7311e-01,
5.4753e-01, 3.9804e-01, 9.4899e-01, 8.2056e-01,
7.7146e-01, 6.3508e-01, 6.2972e-01, 7.4169e-01,
7.8963e-01, 1.0699e-01, 5.7796e-01, 7.2429e-01,
6.3979e-02, 4.5238e-02, 6.3144e-01, 9.8512e-01,
5.1816e-01, 3.2546e-01, 8.7580e-01, 9.7697e-01,
4.6167e-01, 2.4042e-01, 1.1377e-01, 9.7747e-01,
7.4258e-01, 6.3887e-01, 7.3930e-01, 2.3402e-01,
4.1461e-01, 4.8691e-01, 2.7849e-01, 5.9673e-01,
8.6946e-02, 9.5615e-01, 9.7242e-01, 8.9092e-01,
4.1164e-01, 3.3893e-01, 9.4485e-01, 3.2960e-01,
7.1004e-01, 4.1240e-01, 1.1151e-01, 7.6114e-01,
5.5779e-01, 9.3723e-01, 2.2015e-01, 9.0422e-01,
2.5683e-01, 4.6041e-01, 3.3427e-01, 4.3355e-02,
3.1777e-01, 6.8533e-01, 4.9880e-01, 7.0528e-01,
6.2605e-01, 9.9580e-01, 3.8253e-02, 1.0464e-02,
6.2010e-02, 4.9009e-02, 8.8508e-01, 8.3043e-01,
9.5592e-01, 8.5708e-01, 5.1611e-01, 1.7460e-01,
4.5394e-01, 4.2516e-01, 8.0836e-01, 5.2242e-01,
8.0860e-01, 5.1184e-01, 7.3172e-01, 9.2625e-01,
3.8652e-01, 8.6518e-01, 6.9408e-01, 2.5732e-01,
6.0297e-01, 2.2091e-01, 1.2658e-02, 7.6721e-01,
9.6888e-02, 6.6146e-01, 4.4139e-01, 1.9043e-01,
1.1703e-04, 3.3229e-01, 3.7446e-01, 3.2871e-01,
5.5144e-01, 4.6404e-01, 7.9360e-01, 3.2754e-01,
9.8665e-01, 3.2413e-01, 4.6510e-01, 6.8652e-01,
9.6619e-01, 4.0817e-01, 5.0618e-01, 8.0048e-01,
3.4373e-01, 9.9556e-01, 1.4700e-01, 1.2820e-01,
8.0477e-01, 2.3035e-01, 5.4135e-01, 3.8689e-01,
1.8548e-01, 9.7019e-01, 2.2577e-01, 3.2056e-01,
4.1451e-02, 1.3423e-01]), size=(5000, 5000), nnz=250,
layout=torch.sparse_csr)
tensor([0.0595, 0.8939, 0.2592, ..., 0.5348, 0.8468, 0.6804])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([5000, 5000])
Rows: 5000
Size: 25000000
NNZ: 250
Density: 1e-05
Time: 8.58342981338501 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 277505 -ss 5000 -sd 1e-05 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [5000, 5000], "MATRIX_ROWS": 5000, "MATRIX_SIZE": 25000000, "MATRIX_NNZ": 250, "MATRIX_DENSITY": 1e-05, "TIME_S": 9.940149784088135}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 0, 0, ..., 250, 250, 250]),
col_indices=tensor([3014, 4957, 1583, 2867, 2783, 475, 2139, 2382, 3400,
1371, 4277, 2356, 2363, 809, 3070, 166, 954, 1491,
2451, 1189, 312, 609, 4247, 23, 459, 898, 2311,
4831, 338, 2271, 1779, 2454, 4584, 3113, 487, 1534,
2828, 4851, 633, 1451, 3532, 1285, 3207, 3942, 1871,
1291, 465, 1879, 4867, 2362, 2141, 1675, 4085, 954,
3823, 3407, 284, 572, 14, 2939, 2313, 3750, 1562,
2613, 2778, 2860, 3224, 2726, 239, 3475, 2082, 2253,
3516, 1146, 3276, 4995, 2558, 345, 3127, 2150, 75,
826, 1135, 4736, 4690, 2556, 910, 1899, 2387, 947,
695, 304, 2013, 2, 897, 3875, 3772, 1882, 451,
3308, 1440, 3959, 2068, 783, 1822, 1945, 4659, 2440,
4920, 2894, 4923, 1763, 2739, 4990, 4910, 2298, 1281,
1642, 4403, 354, 879, 3935, 4111, 1373, 3061, 948,
4840, 4778, 2992, 2315, 2233, 3168, 3973, 2138, 2299,
4743, 1438, 4906, 254, 4427, 953, 1389, 2612, 1867,
4913, 4975, 2438, 2961, 96, 3956, 1648, 4671, 3511,
2332, 4616, 3807, 1099, 2689, 951, 1859, 3672, 4327,
4946, 755, 3445, 807, 2050, 4470, 819, 3494, 4764,
1487, 2681, 1451, 1828, 600, 2998, 2378, 1446, 2079,
873, 270, 4942, 3757, 4929, 2560, 3562, 3539, 1466,
871, 1762, 750, 1346, 533, 2678, 341, 1486, 2504,
3221, 679, 2068, 2145, 3144, 834, 1808, 3153, 3407,
2103, 1634, 1022, 1783, 3740, 3527, 3470, 3178, 4350,
3648, 2120, 4578, 1596, 135, 2530, 1745, 608, 4825,
4913, 4142, 3012, 1856, 2018, 3602, 264, 275, 4814,
1938, 4047, 1223, 3103, 4868, 3533, 4726, 3018, 1931,
379, 2338, 475, 3665, 4431, 938, 707]),
values=tensor([0.8419, 0.4424, 0.5698, 0.2999, 0.9295, 0.4679, 0.3442,
0.3474, 0.7467, 0.0757, 0.0276, 0.8208, 0.7200, 0.1976,
0.3319, 0.9583, 0.8463, 0.9566, 0.3073, 0.6760, 0.4346,
0.2886, 0.9486, 0.0795, 0.8036, 0.5111, 0.4404, 0.5873,
0.2286, 0.4238, 0.6160, 0.9372, 0.8314, 0.1765, 0.9714,
0.5934, 0.0764, 0.5254, 0.7722, 0.8765, 0.7821, 0.7165,
0.7425, 0.1690, 0.9418, 0.7089, 0.3090, 0.3146, 0.3776,
0.3970, 0.7107, 0.4232, 0.2742, 0.1785, 0.3661, 0.7381,
0.7677, 0.2922, 0.0118, 0.5142, 0.3228, 0.6287, 0.6950,
0.5212, 0.9233, 0.5583, 0.3402, 0.9655, 0.1707, 0.5180,
0.7601, 0.0519, 0.3853, 0.1663, 0.4842, 0.9445, 0.1159,
0.1236, 0.2320, 0.4008, 0.3127, 0.0194, 0.2149, 0.2742,
0.3828, 0.5264, 0.2515, 0.8214, 0.1769, 0.1933, 0.8188,
0.5274, 0.2875, 0.2494, 0.8088, 0.9923, 0.5445, 0.3175,
0.6285, 0.6236, 0.2042, 0.2625, 0.5051, 0.4802, 0.6055,
0.2595, 0.3970, 0.4291, 0.2183, 0.7748, 0.7343, 0.0474,
0.5801, 0.6534, 0.2948, 0.0363, 0.3237, 0.2880, 0.2211,
0.1790, 0.3192, 0.9079, 0.1088, 0.8037, 0.5242, 0.3090,
0.6078, 0.5167, 0.1361, 0.1093, 0.6079, 0.0095, 0.5118,
0.3018, 0.1316, 0.6571, 0.0073, 0.3654, 0.4280, 0.8191,
0.3184, 0.2360, 0.6869, 0.0155, 0.5085, 0.4025, 0.0799,
0.7194, 0.4048, 0.5539, 0.2632, 0.0734, 0.9784, 0.3601,
0.9418, 0.0499, 0.8840, 0.6116, 0.9865, 0.6081, 0.4861,
0.7266, 0.7795, 0.1224, 0.6387, 0.9470, 0.4315, 0.0825,
0.8006, 0.5528, 0.3202, 0.1662, 0.3257, 0.8268, 0.0860,
0.4786, 0.2279, 0.0058, 0.4003, 0.0577, 0.1538, 0.9729,
0.3529, 0.3205, 0.9176, 0.5843, 0.6548, 0.1570, 0.8380,
0.7278, 0.2116, 0.1503, 0.0103, 0.8089, 0.9813, 0.7760,
0.2123, 0.9690, 0.9240, 0.5892, 0.4778, 0.5100, 0.0404,
0.6261, 0.6426, 0.9521, 0.0053, 0.5755, 0.0743, 0.7500,
0.3281, 0.4225, 0.6900, 0.0916, 0.8990, 0.2711, 0.5755,
0.5712, 0.7556, 0.0051, 0.6971, 0.0437, 0.5565, 0.4256,
0.2960, 0.6043, 0.6836, 0.9303, 0.4472, 0.6016, 0.6132,
0.9503, 0.8339, 0.2697, 0.0658, 0.7983, 0.4874, 0.1771,
0.9875, 0.2001, 0.2752, 0.5608, 0.4997, 0.6797, 0.1612,
0.9007, 0.9904, 0.7264, 0.3981, 0.6661]),
size=(5000, 5000), nnz=250, layout=torch.sparse_csr)
tensor([0.5019, 0.1367, 0.6742, ..., 0.0249, 0.2703, 0.5698])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([5000, 5000])
Rows: 5000
Size: 25000000
NNZ: 250
Density: 1e-05
Time: 9.940149784088135 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 293134 -ss 5000 -sd 1e-05 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [5000, 5000], "MATRIX_ROWS": 5000, "MATRIX_SIZE": 25000000, "MATRIX_NNZ": 250, "MATRIX_DENSITY": 1e-05, "TIME_S": 10.89356017112732}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 0, 0, ..., 250, 250, 250]),
col_indices=tensor([3878, 1793, 196, 4523, 2590, 2367, 223, 4753, 811,
1344, 3831, 3891, 1471, 342, 75, 2706, 3424, 2402,
4777, 1498, 772, 4383, 2094, 2326, 2946, 1126, 2886,
1923, 932, 4969, 3541, 896, 863, 2668, 4869, 4410,
1937, 3764, 94, 3879, 1282, 4972, 2002, 1481, 4954,
2173, 3425, 2770, 4498, 897, 827, 829, 4189, 4991,
1934, 1179, 1128, 2114, 2395, 2017, 3561, 4691, 2694,
1416, 4554, 620, 4382, 4973, 3582, 230, 4891, 3107,
1979, 140, 933, 4466, 308, 3556, 3173, 4882, 4797,
1238, 3925, 3354, 291, 1290, 414, 2445, 3042, 2325,
2660, 1731, 777, 3782, 2858, 3541, 2112, 2412, 4004,
942, 1750, 1450, 45, 960, 1184, 3190, 4107, 4960,
4877, 4158, 1493, 3953, 2210, 1987, 3321, 3595, 1029,
1281, 3168, 3718, 1747, 2899, 1694, 1765, 2658, 2297,
2811, 4794, 2166, 3385, 3144, 590, 756, 1857, 2472,
2864, 4092, 2483, 1698, 3039, 4797, 2893, 4815, 1160,
92, 3486, 728, 546, 1233, 1206, 3098, 284, 3217,
1908, 3538, 556, 1018, 3457, 4789, 3509, 986, 1353,
3714, 674, 3739, 3917, 378, 4295, 1240, 678, 634,
156, 182, 2959, 787, 2431, 894, 4155, 1278, 4710,
115, 3800, 3528, 4651, 4055, 3457, 4797, 3790, 2898,
2898, 1677, 2106, 3532, 1869, 3926, 1788, 4954, 1802,
3662, 3116, 1672, 1899, 2743, 4402, 201, 2790, 4915,
3309, 2448, 4340, 71, 1083, 3547, 1833, 4517, 4811,
4522, 4837, 4905, 1773, 2748, 2712, 2488, 4842, 2297,
377, 2695, 2905, 534, 1022, 2504, 1436, 3486, 3980,
4913, 361, 4684, 2741, 722, 1718, 3274, 513, 1785,
4555, 575, 662, 3842, 1584, 2198, 215]),
values=tensor([0.8076, 0.3370, 0.6780, 0.9299, 0.5410, 0.0897, 0.3343,
0.8017, 0.5673, 0.5602, 0.9800, 0.8553, 0.3447, 0.6119,
0.3490, 0.5758, 0.1388, 0.7568, 0.7228, 0.2456, 0.6799,
0.7488, 0.1368, 0.7230, 0.3714, 0.8061, 0.2178, 0.6691,
0.7090, 0.6240, 0.5615, 0.6385, 0.8034, 0.6963, 0.9896,
0.1078, 0.2316, 0.3754, 0.7350, 0.4907, 0.3665, 0.2209,
0.4611, 0.7569, 0.4815, 0.7270, 0.4688, 0.5127, 0.0439,
0.4951, 0.3454, 0.1899, 0.8750, 0.1915, 0.8080, 0.6042,
0.7305, 0.2510, 0.4960, 0.3143, 0.3207, 0.3323, 0.5478,
0.3218, 0.1649, 0.9155, 0.2697, 0.4415, 0.6177, 0.1457,
0.9256, 0.6524, 0.8106, 0.1943, 0.2636, 0.7375, 0.5837,
0.4529, 0.4107, 0.4337, 0.4074, 0.1673, 0.9988, 0.7338,
0.1243, 0.9778, 0.4221, 0.2348, 0.5442, 0.1259, 0.4222,
0.6127, 0.0857, 0.6974, 0.0596, 0.3553, 0.4614, 0.5799,
0.4404, 0.3360, 0.3314, 0.9445, 0.7231, 0.9851, 0.8853,
0.4987, 0.3871, 0.5069, 0.6349, 0.9384, 0.3450, 0.4613,
0.2127, 0.4994, 0.0034, 0.9538, 0.3203, 0.8248, 0.5140,
0.0568, 0.3913, 0.0456, 0.0790, 0.1457, 0.8710, 0.7025,
0.5191, 0.7160, 0.2410, 0.7547, 0.7169, 0.9282, 0.0473,
0.4454, 0.5093, 0.4795, 0.3417, 0.5014, 0.0605, 0.9341,
0.8068, 0.8325, 0.0916, 0.8219, 0.9882, 0.3617, 0.8114,
0.3412, 0.2133, 0.4138, 0.2870, 0.1987, 0.5576, 0.8136,
0.4067, 0.6195, 0.5018, 0.5513, 0.5252, 0.0402, 0.7889,
0.3122, 0.6215, 0.9385, 0.7669, 0.1080, 0.2818, 0.0494,
0.0251, 0.3317, 0.4666, 0.5981, 0.5539, 0.1688, 0.7416,
0.8841, 0.4123, 0.1102, 0.1371, 0.7232, 0.6598, 0.7427,
0.8150, 0.1180, 0.3866, 0.1447, 0.4442, 0.5099, 0.1417,
0.2917, 0.8599, 0.3553, 0.2307, 0.1388, 0.1482, 0.8529,
0.3988, 0.9926, 0.3184, 0.2404, 0.4847, 0.5288, 0.0738,
0.0517, 0.1797, 0.1796, 0.7215, 0.5955, 0.6432, 0.0017,
0.6486, 0.6664, 0.4487, 0.7630, 0.7774, 0.9276, 0.9518,
0.4507, 0.3399, 0.7495, 0.4581, 0.6140, 0.0659, 0.8137,
0.4343, 0.4836, 0.5681, 0.7947, 0.1417, 0.8229, 0.0824,
0.2070, 0.8783, 0.3511, 0.9580, 0.1053, 0.3375, 0.2396,
0.0513, 0.5334, 0.3977, 0.6765, 0.1035, 0.8974, 0.8093,
0.7238, 0.8002, 0.6243, 0.9654, 0.2803]),
size=(5000, 5000), nnz=250, layout=torch.sparse_csr)
tensor([0.4617, 0.6014, 0.4133, ..., 0.3579, 0.3877, 0.5185])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([5000, 5000])
Rows: 5000
Size: 25000000
NNZ: 250
Density: 1e-05
Time: 10.89356017112732 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 0, 0, ..., 250, 250, 250]),
col_indices=tensor([3878, 1793, 196, 4523, 2590, 2367, 223, 4753, 811,
1344, 3831, 3891, 1471, 342, 75, 2706, 3424, 2402,
4777, 1498, 772, 4383, 2094, 2326, 2946, 1126, 2886,
1923, 932, 4969, 3541, 896, 863, 2668, 4869, 4410,
1937, 3764, 94, 3879, 1282, 4972, 2002, 1481, 4954,
2173, 3425, 2770, 4498, 897, 827, 829, 4189, 4991,
1934, 1179, 1128, 2114, 2395, 2017, 3561, 4691, 2694,
1416, 4554, 620, 4382, 4973, 3582, 230, 4891, 3107,
1979, 140, 933, 4466, 308, 3556, 3173, 4882, 4797,
1238, 3925, 3354, 291, 1290, 414, 2445, 3042, 2325,
2660, 1731, 777, 3782, 2858, 3541, 2112, 2412, 4004,
942, 1750, 1450, 45, 960, 1184, 3190, 4107, 4960,
4877, 4158, 1493, 3953, 2210, 1987, 3321, 3595, 1029,
1281, 3168, 3718, 1747, 2899, 1694, 1765, 2658, 2297,
2811, 4794, 2166, 3385, 3144, 590, 756, 1857, 2472,
2864, 4092, 2483, 1698, 3039, 4797, 2893, 4815, 1160,
92, 3486, 728, 546, 1233, 1206, 3098, 284, 3217,
1908, 3538, 556, 1018, 3457, 4789, 3509, 986, 1353,
3714, 674, 3739, 3917, 378, 4295, 1240, 678, 634,
156, 182, 2959, 787, 2431, 894, 4155, 1278, 4710,
115, 3800, 3528, 4651, 4055, 3457, 4797, 3790, 2898,
2898, 1677, 2106, 3532, 1869, 3926, 1788, 4954, 1802,
3662, 3116, 1672, 1899, 2743, 4402, 201, 2790, 4915,
3309, 2448, 4340, 71, 1083, 3547, 1833, 4517, 4811,
4522, 4837, 4905, 1773, 2748, 2712, 2488, 4842, 2297,
377, 2695, 2905, 534, 1022, 2504, 1436, 3486, 3980,
4913, 361, 4684, 2741, 722, 1718, 3274, 513, 1785,
4555, 575, 662, 3842, 1584, 2198, 215]),
values=tensor([0.8076, 0.3370, 0.6780, 0.9299, 0.5410, 0.0897, 0.3343,
0.8017, 0.5673, 0.5602, 0.9800, 0.8553, 0.3447, 0.6119,
0.3490, 0.5758, 0.1388, 0.7568, 0.7228, 0.2456, 0.6799,
0.7488, 0.1368, 0.7230, 0.3714, 0.8061, 0.2178, 0.6691,
0.7090, 0.6240, 0.5615, 0.6385, 0.8034, 0.6963, 0.9896,
0.1078, 0.2316, 0.3754, 0.7350, 0.4907, 0.3665, 0.2209,
0.4611, 0.7569, 0.4815, 0.7270, 0.4688, 0.5127, 0.0439,
0.4951, 0.3454, 0.1899, 0.8750, 0.1915, 0.8080, 0.6042,
0.7305, 0.2510, 0.4960, 0.3143, 0.3207, 0.3323, 0.5478,
0.3218, 0.1649, 0.9155, 0.2697, 0.4415, 0.6177, 0.1457,
0.9256, 0.6524, 0.8106, 0.1943, 0.2636, 0.7375, 0.5837,
0.4529, 0.4107, 0.4337, 0.4074, 0.1673, 0.9988, 0.7338,
0.1243, 0.9778, 0.4221, 0.2348, 0.5442, 0.1259, 0.4222,
0.6127, 0.0857, 0.6974, 0.0596, 0.3553, 0.4614, 0.5799,
0.4404, 0.3360, 0.3314, 0.9445, 0.7231, 0.9851, 0.8853,
0.4987, 0.3871, 0.5069, 0.6349, 0.9384, 0.3450, 0.4613,
0.2127, 0.4994, 0.0034, 0.9538, 0.3203, 0.8248, 0.5140,
0.0568, 0.3913, 0.0456, 0.0790, 0.1457, 0.8710, 0.7025,
0.5191, 0.7160, 0.2410, 0.7547, 0.7169, 0.9282, 0.0473,
0.4454, 0.5093, 0.4795, 0.3417, 0.5014, 0.0605, 0.9341,
0.8068, 0.8325, 0.0916, 0.8219, 0.9882, 0.3617, 0.8114,
0.3412, 0.2133, 0.4138, 0.2870, 0.1987, 0.5576, 0.8136,
0.4067, 0.6195, 0.5018, 0.5513, 0.5252, 0.0402, 0.7889,
0.3122, 0.6215, 0.9385, 0.7669, 0.1080, 0.2818, 0.0494,
0.0251, 0.3317, 0.4666, 0.5981, 0.5539, 0.1688, 0.7416,
0.8841, 0.4123, 0.1102, 0.1371, 0.7232, 0.6598, 0.7427,
0.8150, 0.1180, 0.3866, 0.1447, 0.4442, 0.5099, 0.1417,
0.2917, 0.8599, 0.3553, 0.2307, 0.1388, 0.1482, 0.8529,
0.3988, 0.9926, 0.3184, 0.2404, 0.4847, 0.5288, 0.0738,
0.0517, 0.1797, 0.1796, 0.7215, 0.5955, 0.6432, 0.0017,
0.6486, 0.6664, 0.4487, 0.7630, 0.7774, 0.9276, 0.9518,
0.4507, 0.3399, 0.7495, 0.4581, 0.6140, 0.0659, 0.8137,
0.4343, 0.4836, 0.5681, 0.7947, 0.1417, 0.8229, 0.0824,
0.2070, 0.8783, 0.3511, 0.9580, 0.1053, 0.3375, 0.2396,
0.0513, 0.5334, 0.3977, 0.6765, 0.1035, 0.8974, 0.8093,
0.7238, 0.8002, 0.6243, 0.9654, 0.2803]),
size=(5000, 5000), nnz=250, layout=torch.sparse_csr)
tensor([0.4617, 0.6014, 0.4133, ..., 0.3579, 0.3877, 0.5185])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([5000, 5000])
Rows: 5000
Size: 25000000
NNZ: 250
Density: 1e-05
Time: 10.89356017112732 seconds
[16.36, 16.36, 16.4, 16.6, 16.6, 16.96, 16.96, 16.88, 16.88, 16.48]
[16.32, 16.28, 19.04, 20.36, 23.52, 24.24, 24.96, 24.96, 22.16, 21.36, 19.68, 19.76, 19.8, 19.64]
14.221415042877197
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 293134, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [5000, 5000], 'MATRIX_ROWS': 5000, 'MATRIX_SIZE': 25000000, 'MATRIX_NNZ': 250, 'MATRIX_DENSITY': 1e-05, 'TIME_S': 10.89356017112732, 'TIME_S_1KI': 0.03716239048055606, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 278.4485914421082, 'W': 19.57952781791354}
[16.36, 16.36, 16.4, 16.6, 16.6, 16.96, 16.96, 16.88, 16.88, 16.48, 16.6, 16.64, 16.68, 16.76, 16.68, 16.56, 16.4, 16.4, 16.52, 16.64]
299.32000000000005
14.966000000000003
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 293134, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [5000, 5000], 'MATRIX_ROWS': 5000, 'MATRIX_SIZE': 25000000, 'MATRIX_NNZ': 250, 'MATRIX_DENSITY': 1e-05, 'TIME_S': 10.89356017112732, 'TIME_S_1KI': 0.03716239048055606, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 278.4485914421082, 'W': 19.57952781791354, 'J_1KI': 0.9499020633638819, 'W_1KI': 0.06679377969772711, 'W_D': 4.613527817913537, 'J_D': 65.610893910408, 'W_D_1KI': 0.01573863085794735, 'J_D_1KI': 5.3690908792386244e-05}

1
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_5000_5e-05.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Altra", "CORES": 16, "ITERATIONS": 151147, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [5000, 5000], "MATRIX_ROWS": 5000, "MATRIX_SIZE": 25000000, "MATRIX_NNZ": 1250, "MATRIX_DENSITY": 5e-05, "TIME_S": 10.619585275650024, "TIME_S_1KI": 0.07025998051995755, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 328.34527337074286, "W": 23.06683265939357, "J_1KI": 2.1723571977660345, "W_1KI": 0.15261191197571614, "W_D": 4.6928326593935665, "J_D": 66.80021679544454, "W_D_1KI": 0.031048136313612352, "J_D_1KI": 0.00020541682146263144}

81
pytorch/output_synthetic_16core_old/altra_16_csr_10_10_10_synthetic_5000_5e-05.output Normal file
View File

@ -0,0 +1,81 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 1000 -ss 5000 -sd 5e-05 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [5000, 5000], "MATRIX_ROWS": 5000, "MATRIX_SIZE": 25000000, "MATRIX_NNZ": 1250, "MATRIX_DENSITY": 5e-05, "TIME_S": 0.07715368270874023}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 0, 0, ..., 1250, 1250, 1250]),
col_indices=tensor([4186, 604, 2911, ..., 3524, 2664, 807]),
values=tensor([0.1303, 0.5472, 0.9541, ..., 0.4453, 0.4813, 0.2933]),
size=(5000, 5000), nnz=1250, layout=torch.sparse_csr)
tensor([0.2363, 0.5745, 0.8536, ..., 0.3028, 0.7626, 0.7945])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([5000, 5000])
Rows: 5000
Size: 25000000
NNZ: 1250
Density: 5e-05
Time: 0.07715368270874023 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 136092 -ss 5000 -sd 5e-05 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [5000, 5000], "MATRIX_ROWS": 5000, "MATRIX_SIZE": 25000000, "MATRIX_NNZ": 1250, "MATRIX_DENSITY": 5e-05, "TIME_S": 9.454103946685791}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 0, 0, ..., 1250, 1250, 1250]),
col_indices=tensor([2642, 3295, 3317, ..., 552, 1688, 3754]),
values=tensor([0.5853, 0.8410, 0.7758, ..., 0.7543, 0.4171, 0.3907]),
size=(5000, 5000), nnz=1250, layout=torch.sparse_csr)
tensor([0.4145, 0.1634, 0.4401, ..., 0.9903, 0.7928, 0.8495])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([5000, 5000])
Rows: 5000
Size: 25000000
NNZ: 1250
Density: 5e-05
Time: 9.454103946685791 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-altra.sif', '-c', 'numactl --cpunodebind=0 --membind=0 python3 spmv.py synthetic csr 151147 -ss 5000 -sd 5e-05 -c 16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [5000, 5000], "MATRIX_ROWS": 5000, "MATRIX_SIZE": 25000000, "MATRIX_NNZ": 1250, "MATRIX_DENSITY": 5e-05, "TIME_S": 10.619585275650024}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 0, 0, ..., 1250, 1250, 1250]),
col_indices=tensor([2120, 4070, 3230, ..., 2901, 3405, 168]),
values=tensor([0.1519, 0.7232, 0.6282, ..., 0.2528, 0.5199, 0.9452]),
size=(5000, 5000), nnz=1250, layout=torch.sparse_csr)
tensor([0.2553, 0.4766, 0.2217, ..., 0.4056, 0.3500, 0.9553])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([5000, 5000])
Rows: 5000
Size: 25000000
NNZ: 1250
Density: 5e-05
Time: 10.619585275650024 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at /space/jenkins/workspace/Releases/pytorch-dls/pytorch-dls/aten/src/ATen/SparseCsrTensorImpl.cpp:55.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 0, 0, ..., 1250, 1250, 1250]),
col_indices=tensor([2120, 4070, 3230, ..., 2901, 3405, 168]),
values=tensor([0.1519, 0.7232, 0.6282, ..., 0.2528, 0.5199, 0.9452]),
size=(5000, 5000), nnz=1250, layout=torch.sparse_csr)
tensor([0.2553, 0.4766, 0.2217, ..., 0.4056, 0.3500, 0.9553])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([5000, 5000])
Rows: 5000
Size: 25000000
NNZ: 1250
Density: 5e-05
Time: 10.619585275650024 seconds
[20.44, 20.36, 20.28, 20.16, 20.04, 20.16, 20.28, 20.32, 20.56, 20.56]
[20.72, 20.76, 20.8, 24.32, 26.28, 28.48, 29.36, 29.52, 26.16, 23.92, 23.8, 23.64, 23.64, 23.56]
14.234519243240356
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 151147, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [5000, 5000], 'MATRIX_ROWS': 5000, 'MATRIX_SIZE': 25000000, 'MATRIX_NNZ': 1250, 'MATRIX_DENSITY': 5e-05, 'TIME_S': 10.619585275650024, 'TIME_S_1KI': 0.07025998051995755, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 328.34527337074286, 'W': 23.06683265939357}
[20.44, 20.36, 20.28, 20.16, 20.04, 20.16, 20.28, 20.32, 20.56, 20.56, 20.24, 20.2, 20.36, 20.68, 20.96, 20.8, 20.68, 20.4, 20.44, 20.36]
367.48
18.374000000000002
{'CPU': 'Altra', 'CORES': 16, 'ITERATIONS': 151147, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [5000, 5000], 'MATRIX_ROWS': 5000, 'MATRIX_SIZE': 25000000, 'MATRIX_NNZ': 1250, 'MATRIX_DENSITY': 5e-05, 'TIME_S': 10.619585275650024, 'TIME_S_1KI': 0.07025998051995755, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 328.34527337074286, 'W': 23.06683265939357, 'J_1KI': 2.1723571977660345, 'W_1KI': 0.15261191197571614, 'W_D': 4.6928326593935665, 'J_D': 66.80021679544454, 'W_D_1KI': 0.031048136313612352, 'J_D_1KI': 0.00020541682146263144}

1
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_100000_0.0001.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Epyc 7313P", "CORES": 16, "ITERATIONS": 63031, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [100000, 100000], "MATRIX_ROWS": 100000, "MATRIX_SIZE": 10000000000, "MATRIX_NNZ": 1000000, "MATRIX_DENSITY": 0.0001, "TIME_S": 10.264819622039795, "TIME_S_1KI": 0.16285351052719765, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 1907.2002365589144, "W": 143.8, "J_1KI": 30.25813070646054, "W_1KI": 2.2814170804842067, "W_D": 106.65425000000002, "J_D": 1414.5411045202616, "W_D_1KI": 1.6920919864828419, "J_D_1KI": 0.026845393322061237}

85
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_100000_0.0001.output Normal file
View File

@ -0,0 +1,85 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '1000', '-ss', '100000', '-sd', '0.0001', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [100000, 100000], "MATRIX_ROWS": 100000, "MATRIX_SIZE": 10000000000, "MATRIX_NNZ": 1000000, "MATRIX_DENSITY": 0.0001, "TIME_S": 0.20868682861328125}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 11, 23, ..., 999975,
999990, 1000000]),
col_indices=tensor([ 1102, 1885, 5689, ..., 70464, 82505, 82637]),
values=tensor([0.9145, 0.6563, 0.0210, ..., 0.3467, 0.9517, 0.4307]),
size=(100000, 100000), nnz=1000000, layout=torch.sparse_csr)
tensor([0.3954, 0.8531, 0.4592, ..., 0.1653, 0.9288, 0.8508])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([100000, 100000])
Rows: 100000
Size: 10000000000
NNZ: 1000000
Density: 0.0001
Time: 0.20868682861328125 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '50314', '-ss', '100000', '-sd', '0.0001', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [100000, 100000], "MATRIX_ROWS": 100000, "MATRIX_SIZE": 10000000000, "MATRIX_NNZ": 1000000, "MATRIX_DENSITY": 0.0001, "TIME_S": 8.38151502609253}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 9, 15, ..., 999976,
999987, 1000000]),
col_indices=tensor([ 9326, 16949, 19479, ..., 70135, 76689, 93251]),
values=tensor([0.2491, 0.4486, 0.5526, ..., 0.3620, 0.8491, 0.1510]),
size=(100000, 100000), nnz=1000000, layout=torch.sparse_csr)
tensor([0.1294, 0.2549, 0.0676, ..., 0.6377, 0.6452, 0.0657])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([100000, 100000])
Rows: 100000
Size: 10000000000
NNZ: 1000000
Density: 0.0001
Time: 8.38151502609253 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '63031', '-ss', '100000', '-sd', '0.0001', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [100000, 100000], "MATRIX_ROWS": 100000, "MATRIX_SIZE": 10000000000, "MATRIX_NNZ": 1000000, "MATRIX_DENSITY": 0.0001, "TIME_S": 10.264819622039795}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 8, 17, ..., 999978,
999986, 1000000]),
col_indices=tensor([ 1906, 11602, 20474, ..., 94634, 95193, 99629]),
values=tensor([0.7595, 0.5479, 0.3671, ..., 0.3196, 0.4186, 0.5082]),
size=(100000, 100000), nnz=1000000, layout=torch.sparse_csr)
tensor([0.5397, 0.2720, 0.7091, ..., 0.7919, 0.2241, 0.5973])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([100000, 100000])
Rows: 100000
Size: 10000000000
NNZ: 1000000
Density: 0.0001
Time: 10.264819622039795 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 8, 17, ..., 999978,
999986, 1000000]),
col_indices=tensor([ 1906, 11602, 20474, ..., 94634, 95193, 99629]),
values=tensor([0.7595, 0.5479, 0.3671, ..., 0.3196, 0.4186, 0.5082]),
size=(100000, 100000), nnz=1000000, layout=torch.sparse_csr)
tensor([0.5397, 0.2720, 0.7091, ..., 0.7919, 0.2241, 0.5973])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([100000, 100000])
Rows: 100000
Size: 10000000000
NNZ: 1000000
Density: 0.0001
Time: 10.264819622039795 seconds
[40.75, 39.66, 39.67, 39.19, 39.32, 45.15, 39.35, 39.19, 39.95, 39.54]
[143.8]
13.262866735458374
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 63031, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [100000, 100000], 'MATRIX_ROWS': 100000, 'MATRIX_SIZE': 10000000000, 'MATRIX_NNZ': 1000000, 'MATRIX_DENSITY': 0.0001, 'TIME_S': 10.264819622039795, 'TIME_S_1KI': 0.16285351052719765, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 1907.2002365589144, 'W': 143.8}
[40.75, 39.66, 39.67, 39.19, 39.32, 45.15, 39.35, 39.19, 39.95, 39.54, 40.42, 44.44, 57.71, 39.25, 40.02, 40.75, 39.74, 39.58, 39.68, 39.82]
742.915
37.14575
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 63031, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [100000, 100000], 'MATRIX_ROWS': 100000, 'MATRIX_SIZE': 10000000000, 'MATRIX_NNZ': 1000000, 'MATRIX_DENSITY': 0.0001, 'TIME_S': 10.264819622039795, 'TIME_S_1KI': 0.16285351052719765, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 1907.2002365589144, 'W': 143.8, 'J_1KI': 30.25813070646054, 'W_1KI': 2.2814170804842067, 'W_D': 106.65425000000002, 'J_D': 1414.5411045202616, 'W_D_1KI': 1.6920919864828419, 'J_D_1KI': 0.026845393322061237}

1
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_100000_0.001.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Epyc 7313P", "CORES": 16, "ITERATIONS": 4290, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [100000, 100000], "MATRIX_ROWS": 100000, "MATRIX_SIZE": 10000000000, "MATRIX_NNZ": 10000000, "MATRIX_DENSITY": 0.001, "TIME_S": 10.725477457046509, "TIME_S_1KI": 2.500111295348837, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 2014.465433692932, "W": 126.69, "J_1KI": 469.57236216618463, "W_1KI": 29.53146853146853, "W_D": 91.17699999999999, "J_D": 1449.7822625923156, "W_D_1KI": 21.25337995337995, "J_D_1KI": 4.954167821300688}

65
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_100000_0.001.output Normal file
View File

@ -0,0 +1,65 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '1000', '-ss', '100000', '-sd', '0.001', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [100000, 100000], "MATRIX_ROWS": 100000, "MATRIX_SIZE": 10000000000, "MATRIX_NNZ": 10000000, "MATRIX_DENSITY": 0.001, "TIME_S": 2.4475483894348145}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 108, 211, ..., 9999795,
9999912, 10000000]),
col_indices=tensor([ 147, 1138, 2699, ..., 95915, 96101, 99505]),
values=tensor([0.5370, 0.7637, 0.8320, ..., 0.1671, 0.6910, 0.1145]),
size=(100000, 100000), nnz=10000000, layout=torch.sparse_csr)
tensor([0.0022, 0.6683, 0.3307, ..., 0.4747, 0.3475, 0.4636])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([100000, 100000])
Rows: 100000
Size: 10000000000
NNZ: 10000000
Density: 0.001
Time: 2.4475483894348145 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '4290', '-ss', '100000', '-sd', '0.001', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [100000, 100000], "MATRIX_ROWS": 100000, "MATRIX_SIZE": 10000000000, "MATRIX_NNZ": 10000000, "MATRIX_DENSITY": 0.001, "TIME_S": 10.725477457046509}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 113, 209, ..., 9999816,
9999914, 10000000]),
col_indices=tensor([ 524, 3053, 3097, ..., 98248, 99944, 99996]),
values=tensor([0.2951, 0.6504, 0.4617, ..., 0.6241, 0.9747, 0.0943]),
size=(100000, 100000), nnz=10000000, layout=torch.sparse_csr)
tensor([0.1529, 0.0141, 0.4287, ..., 0.1937, 0.2308, 0.9820])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([100000, 100000])
Rows: 100000
Size: 10000000000
NNZ: 10000000
Density: 0.001
Time: 10.725477457046509 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 113, 209, ..., 9999816,
9999914, 10000000]),
col_indices=tensor([ 524, 3053, 3097, ..., 98248, 99944, 99996]),
values=tensor([0.2951, 0.6504, 0.4617, ..., 0.6241, 0.9747, 0.0943]),
size=(100000, 100000), nnz=10000000, layout=torch.sparse_csr)
tensor([0.1529, 0.0141, 0.4287, ..., 0.1937, 0.2308, 0.9820])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([100000, 100000])
Rows: 100000
Size: 10000000000
NNZ: 10000000
Density: 0.001
Time: 10.725477457046509 seconds
[39.92, 39.19, 39.59, 39.28, 39.81, 39.63, 39.63, 39.45, 39.41, 39.18]
[126.69]
15.900745391845703
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 4290, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [100000, 100000], 'MATRIX_ROWS': 100000, 'MATRIX_SIZE': 10000000000, 'MATRIX_NNZ': 10000000, 'MATRIX_DENSITY': 0.001, 'TIME_S': 10.725477457046509, 'TIME_S_1KI': 2.500111295348837, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 2014.465433692932, 'W': 126.69}
[39.92, 39.19, 39.59, 39.28, 39.81, 39.63, 39.63, 39.45, 39.41, 39.18, 40.85, 39.15, 39.3, 39.24, 39.74, 39.48, 39.55, 39.09, 39.1, 39.29]
710.26
35.513
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 4290, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [100000, 100000], 'MATRIX_ROWS': 100000, 'MATRIX_SIZE': 10000000000, 'MATRIX_NNZ': 10000000, 'MATRIX_DENSITY': 0.001, 'TIME_S': 10.725477457046509, 'TIME_S_1KI': 2.500111295348837, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 2014.465433692932, 'W': 126.69, 'J_1KI': 469.57236216618463, 'W_1KI': 29.53146853146853, 'W_D': 91.17699999999999, 'J_D': 1449.7822625923156, 'W_D_1KI': 21.25337995337995, 'J_D_1KI': 4.954167821300688}

1
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_100000_1e-05.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Epyc 7313P", "CORES": 16, "ITERATIONS": 102924, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [100000, 100000], "MATRIX_ROWS": 100000, "MATRIX_SIZE": 10000000000, "MATRIX_NNZ": 100000, "MATRIX_DENSITY": 1e-05, "TIME_S": 10.60866904258728, "TIME_S_1KI": 0.103072840567674, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 1542.0244372987747, "W": 115.47, "J_1KI": 14.982165843717448, "W_1KI": 1.121895767750962, "W_D": 79.97325000000001, "J_D": 1067.989138565898, "W_D_1KI": 0.7770126501107615, "J_D_1KI": 0.00754938255519375}

85
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_100000_1e-05.output Normal file
View File

@ -0,0 +1,85 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '1000', '-ss', '100000', '-sd', '1e-05', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [100000, 100000], "MATRIX_ROWS": 100000, "MATRIX_SIZE": 10000000000, "MATRIX_NNZ": 100000, "MATRIX_DENSITY": 1e-05, "TIME_S": 0.12978029251098633}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 3, 4, ..., 99999, 100000,
100000]),
col_indices=tensor([21616, 77637, 85619, ..., 53732, 81470, 6094]),
values=tensor([0.4857, 0.1991, 0.9153, ..., 0.9203, 0.8308, 0.8562]),
size=(100000, 100000), nnz=100000, layout=torch.sparse_csr)
tensor([0.0197, 0.8164, 0.2872, ..., 0.9903, 0.3891, 0.9778])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([100000, 100000])
Rows: 100000
Size: 10000000000
NNZ: 100000
Density: 1e-05
Time: 0.12978029251098633 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '80905', '-ss', '100000', '-sd', '1e-05', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [100000, 100000], "MATRIX_ROWS": 100000, "MATRIX_SIZE": 10000000000, "MATRIX_NNZ": 100000, "MATRIX_DENSITY": 1e-05, "TIME_S": 8.253613233566284}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 2, 3, ..., 99999, 99999,
100000]),
col_indices=tensor([18950, 61338, 17160, ..., 57514, 79997, 96494]),
values=tensor([0.7220, 0.1840, 0.6067, ..., 0.9597, 0.4652, 0.5228]),
size=(100000, 100000), nnz=100000, layout=torch.sparse_csr)
tensor([0.0221, 0.6414, 0.1516, ..., 0.3018, 0.8902, 0.3461])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([100000, 100000])
Rows: 100000
Size: 10000000000
NNZ: 100000
Density: 1e-05
Time: 8.253613233566284 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '102924', '-ss', '100000', '-sd', '1e-05', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [100000, 100000], "MATRIX_ROWS": 100000, "MATRIX_SIZE": 10000000000, "MATRIX_NNZ": 100000, "MATRIX_DENSITY": 1e-05, "TIME_S": 10.60866904258728}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 0, 0, ..., 99999, 99999,
100000]),
col_indices=tensor([ 4611, 80501, 8771, ..., 95435, 27789, 45343]),
values=tensor([0.8274, 0.0201, 0.6109, ..., 0.4116, 0.6491, 0.0785]),
size=(100000, 100000), nnz=100000, layout=torch.sparse_csr)
tensor([0.0461, 0.3256, 0.3375, ..., 0.6234, 0.9526, 0.7301])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([100000, 100000])
Rows: 100000
Size: 10000000000
NNZ: 100000
Density: 1e-05
Time: 10.60866904258728 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 0, 0, ..., 99999, 99999,
100000]),
col_indices=tensor([ 4611, 80501, 8771, ..., 95435, 27789, 45343]),
values=tensor([0.8274, 0.0201, 0.6109, ..., 0.4116, 0.6491, 0.0785]),
size=(100000, 100000), nnz=100000, layout=torch.sparse_csr)
tensor([0.0461, 0.3256, 0.3375, ..., 0.6234, 0.9526, 0.7301])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([100000, 100000])
Rows: 100000
Size: 10000000000
NNZ: 100000
Density: 1e-05
Time: 10.60866904258728 seconds
[39.93, 39.22, 39.43, 40.14, 39.51, 39.36, 39.3, 39.3, 39.26, 39.1]
[115.47]
13.354329586029053
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 102924, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [100000, 100000], 'MATRIX_ROWS': 100000, 'MATRIX_SIZE': 10000000000, 'MATRIX_NNZ': 100000, 'MATRIX_DENSITY': 1e-05, 'TIME_S': 10.60866904258728, 'TIME_S_1KI': 0.103072840567674, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 1542.0244372987747, 'W': 115.47}
[39.93, 39.22, 39.43, 40.14, 39.51, 39.36, 39.3, 39.3, 39.26, 39.1, 41.76, 39.08, 39.78, 39.45, 39.66, 39.16, 39.27, 39.06, 39.08, 38.96]
709.935
35.49675
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 102924, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [100000, 100000], 'MATRIX_ROWS': 100000, 'MATRIX_SIZE': 10000000000, 'MATRIX_NNZ': 100000, 'MATRIX_DENSITY': 1e-05, 'TIME_S': 10.60866904258728, 'TIME_S_1KI': 0.103072840567674, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 1542.0244372987747, 'W': 115.47, 'J_1KI': 14.982165843717448, 'W_1KI': 1.121895767750962, 'W_D': 79.97325000000001, 'J_D': 1067.989138565898, 'W_D_1KI': 0.7770126501107615, 'J_D_1KI': 0.00754938255519375}

1
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_100000_5e-05.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Epyc 7313P", "CORES": 16, "ITERATIONS": 85448, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [100000, 100000], "MATRIX_ROWS": 100000, "MATRIX_SIZE": 10000000000, "MATRIX_NNZ": 500000, "MATRIX_DENSITY": 5e-05, "TIME_S": 10.79839825630188, "TIME_S_1KI": 0.12637391461826936, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 1847.2158340501787, "W": 132.18, "J_1KI": 21.618011352520583, "W_1KI": 1.5469057204381613, "W_D": 96.35400000000001, "J_D": 1346.5473935093883, "W_D_1KI": 1.127633180413819, "J_D_1KI": 0.013196718242835633}

85
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_100000_5e-05.output Normal file
View File

@ -0,0 +1,85 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '1000', '-ss', '100000', '-sd', '5e-05', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [100000, 100000], "MATRIX_ROWS": 100000, "MATRIX_SIZE": 10000000000, "MATRIX_NNZ": 500000, "MATRIX_DENSITY": 5e-05, "TIME_S": 0.157515287399292}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 2, 8, ..., 499988, 499996,
500000]),
col_indices=tensor([50162, 75153, 30191, ..., 32389, 47580, 60210]),
values=tensor([0.9007, 0.9447, 0.0410, ..., 0.6472, 0.2952, 0.4267]),
size=(100000, 100000), nnz=500000, layout=torch.sparse_csr)
tensor([0.3259, 0.8902, 0.7186, ..., 0.8330, 0.5312, 0.8917])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([100000, 100000])
Rows: 100000
Size: 10000000000
NNZ: 500000
Density: 5e-05
Time: 0.157515287399292 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '66660', '-ss', '100000', '-sd', '5e-05', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [100000, 100000], "MATRIX_ROWS": 100000, "MATRIX_SIZE": 10000000000, "MATRIX_NNZ": 500000, "MATRIX_DENSITY": 5e-05, "TIME_S": 8.191283702850342}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 4, 8, ..., 499990, 499997,
500000]),
col_indices=tensor([ 3937, 41482, 51345, ..., 57028, 62776, 96568]),
values=tensor([0.3669, 0.7790, 0.6636, ..., 0.0088, 0.3191, 0.1015]),
size=(100000, 100000), nnz=500000, layout=torch.sparse_csr)
tensor([0.1888, 0.6317, 0.9833, ..., 0.5078, 0.6417, 0.5906])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([100000, 100000])
Rows: 100000
Size: 10000000000
NNZ: 500000
Density: 5e-05
Time: 8.191283702850342 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '85448', '-ss', '100000', '-sd', '5e-05', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [100000, 100000], "MATRIX_ROWS": 100000, "MATRIX_SIZE": 10000000000, "MATRIX_NNZ": 500000, "MATRIX_DENSITY": 5e-05, "TIME_S": 10.79839825630188}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 8, 13, ..., 499988, 499995,
500000]),
col_indices=tensor([ 3698, 26087, 35796, ..., 95832, 96289, 98226]),
values=tensor([0.4478, 0.6896, 0.5878, ..., 0.3885, 0.0788, 0.0500]),
size=(100000, 100000), nnz=500000, layout=torch.sparse_csr)
tensor([0.6913, 0.6407, 0.8664, ..., 0.8625, 0.1823, 0.9429])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([100000, 100000])
Rows: 100000
Size: 10000000000
NNZ: 500000
Density: 5e-05
Time: 10.79839825630188 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 8, 13, ..., 499988, 499995,
500000]),
col_indices=tensor([ 3698, 26087, 35796, ..., 95832, 96289, 98226]),
values=tensor([0.4478, 0.6896, 0.5878, ..., 0.3885, 0.0788, 0.0500]),
size=(100000, 100000), nnz=500000, layout=torch.sparse_csr)
tensor([0.6913, 0.6407, 0.8664, ..., 0.8625, 0.1823, 0.9429])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([100000, 100000])
Rows: 100000
Size: 10000000000
NNZ: 500000
Density: 5e-05
Time: 10.79839825630188 seconds
[40.27, 39.58, 39.76, 40.26, 40.31, 39.92, 40.36, 39.5, 39.65, 39.54]
[132.18]
13.975002527236938
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 85448, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [100000, 100000], 'MATRIX_ROWS': 100000, 'MATRIX_SIZE': 10000000000, 'MATRIX_NNZ': 500000, 'MATRIX_DENSITY': 5e-05, 'TIME_S': 10.79839825630188, 'TIME_S_1KI': 0.12637391461826936, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 1847.2158340501787, 'W': 132.18}
[40.27, 39.58, 39.76, 40.26, 40.31, 39.92, 40.36, 39.5, 39.65, 39.54, 40.41, 39.45, 40.31, 39.36, 39.58, 39.39, 39.62, 39.75, 39.86, 39.5]
716.52
35.826
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 85448, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [100000, 100000], 'MATRIX_ROWS': 100000, 'MATRIX_SIZE': 10000000000, 'MATRIX_NNZ': 500000, 'MATRIX_DENSITY': 5e-05, 'TIME_S': 10.79839825630188, 'TIME_S_1KI': 0.12637391461826936, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 1847.2158340501787, 'W': 132.18, 'J_1KI': 21.618011352520583, 'W_1KI': 1.5469057204381613, 'W_D': 96.35400000000001, 'J_D': 1346.5473935093883, 'W_D_1KI': 1.127633180413819, 'J_D_1KI': 0.013196718242835633}

1
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_10000_0.0001.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Epyc 7313P", "CORES": 16, "ITERATIONS": 278690, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 10000, "MATRIX_DENSITY": 0.0001, "TIME_S": 10.3841392993927, "TIME_S_1KI": 0.0372605378714439, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 1292.3170569992064, "W": 98.52, "J_1KI": 4.63711312569237, "W_1KI": 0.3535110696472783, "W_D": 63.16824999999999, "J_D": 828.5973095390796, "W_D_1KI": 0.2266613441458251, "J_D_1KI": 0.0008133099291177477}

81
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_10000_0.0001.output Normal file
View File

@ -0,0 +1,81 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '1000', '-ss', '10000', '-sd', '0.0001', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 10000, "MATRIX_DENSITY": 0.0001, "TIME_S": 0.05305743217468262}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 1, 1, ..., 9999, 9999, 10000]),
col_indices=tensor([2207, 830, 7633, ..., 2513, 8541, 2972]),
values=tensor([0.9417, 0.1071, 0.2127, ..., 0.2034, 0.4535, 0.3737]),
size=(10000, 10000), nnz=10000, layout=torch.sparse_csr)
tensor([0.2095, 0.5712, 0.5435, ..., 0.2564, 0.5818, 0.1577])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 10000
Density: 0.0001
Time: 0.05305743217468262 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '197898', '-ss', '10000', '-sd', '0.0001', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 10000, "MATRIX_DENSITY": 0.0001, "TIME_S": 7.456049680709839}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 0, 2, ..., 10000, 10000, 10000]),
col_indices=tensor([7930, 9951, 4041, ..., 9045, 6420, 8503]),
values=tensor([0.2418, 0.2435, 0.4116, ..., 0.5201, 0.9725, 0.0713]),
size=(10000, 10000), nnz=10000, layout=torch.sparse_csr)
tensor([0.5895, 0.0291, 0.5304, ..., 0.4324, 0.9976, 0.6205])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 10000
Density: 0.0001
Time: 7.456049680709839 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '278690', '-ss', '10000', '-sd', '0.0001', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 10000, "MATRIX_DENSITY": 0.0001, "TIME_S": 10.3841392993927}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 0, 0, ..., 9996, 9998, 10000]),
col_indices=tensor([9574, 4944, 2003, ..., 2641, 7523, 8416]),
values=tensor([0.4157, 0.2537, 0.8916, ..., 0.3966, 0.1591, 0.0732]),
size=(10000, 10000), nnz=10000, layout=torch.sparse_csr)
tensor([0.4368, 0.0363, 0.2687, ..., 0.3029, 0.2331, 0.6830])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 10000
Density: 0.0001
Time: 10.3841392993927 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 0, 0, ..., 9996, 9998, 10000]),
col_indices=tensor([9574, 4944, 2003, ..., 2641, 7523, 8416]),
values=tensor([0.4157, 0.2537, 0.8916, ..., 0.3966, 0.1591, 0.0732]),
size=(10000, 10000), nnz=10000, layout=torch.sparse_csr)
tensor([0.4368, 0.0363, 0.2687, ..., 0.3029, 0.2331, 0.6830])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 10000
Density: 0.0001
Time: 10.3841392993927 seconds
[40.74, 38.88, 38.93, 39.04, 38.99, 38.97, 39.42, 39.32, 39.26, 38.71]
[98.52]
13.11730670928955
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 278690, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [10000, 10000], 'MATRIX_ROWS': 10000, 'MATRIX_SIZE': 100000000, 'MATRIX_NNZ': 10000, 'MATRIX_DENSITY': 0.0001, 'TIME_S': 10.3841392993927, 'TIME_S_1KI': 0.0372605378714439, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 1292.3170569992064, 'W': 98.52}
[40.74, 38.88, 38.93, 39.04, 38.99, 38.97, 39.42, 39.32, 39.26, 38.71, 39.37, 39.1, 39.73, 39.04, 39.15, 38.73, 39.2, 38.61, 38.78, 44.95]
707.0350000000001
35.35175
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 278690, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [10000, 10000], 'MATRIX_ROWS': 10000, 'MATRIX_SIZE': 100000000, 'MATRIX_NNZ': 10000, 'MATRIX_DENSITY': 0.0001, 'TIME_S': 10.3841392993927, 'TIME_S_1KI': 0.0372605378714439, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 1292.3170569992064, 'W': 98.52, 'J_1KI': 4.63711312569237, 'W_1KI': 0.3535110696472783, 'W_D': 63.16824999999999, 'J_D': 828.5973095390796, 'W_D_1KI': 0.2266613441458251, 'J_D_1KI': 0.0008133099291177477}

1
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_10000_0.001.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Epyc 7313P", "CORES": 16, "ITERATIONS": 181643, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 100000, "MATRIX_DENSITY": 0.001, "TIME_S": 10.058825254440308, "TIME_S_1KI": 0.05537689453730839, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 1334.3994569778442, "W": 108.0, "J_1KI": 7.346275149484671, "W_1KI": 0.5945728709611711, "W_D": 72.86524999999999, "J_D": 900.2902780792116, "W_D_1KI": 0.4011453785722543, "J_D_1KI": 0.002208427401949177}

86
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_10000_0.001.output Normal file
View File

@ -0,0 +1,86 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '1000', '-ss', '10000', '-sd', '0.001', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 100000, "MATRIX_DENSITY": 0.001, "TIME_S": 0.07387351989746094}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 11, 20, ..., 99983, 99988,
100000]),
col_indices=tensor([2080, 2520, 2867, ..., 8307, 8901, 9286]),
values=tensor([0.8261, 0.1055, 0.9939, ..., 0.1447, 0.1951, 0.2617]),
size=(10000, 10000), nnz=100000, layout=torch.sparse_csr)
tensor([0.7373, 0.8108, 0.8070, ..., 0.3032, 0.8916, 0.0356])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 100000
Density: 0.001
Time: 0.07387351989746094 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '142134', '-ss', '10000', '-sd', '0.001', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 100000, "MATRIX_DENSITY": 0.001, "TIME_S": 8.216149806976318}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 8, 16, ..., 99977, 99988,
100000]),
col_indices=tensor([ 929, 1145, 1167, ..., 7253, 9439, 9881]),
values=tensor([3.5267e-01, 8.9746e-01, 4.0379e-01, ...,
8.5718e-04, 5.6681e-01, 4.6851e-01]),
size=(10000, 10000), nnz=100000, layout=torch.sparse_csr)
tensor([0.4055, 0.0658, 0.7904, ..., 0.2959, 0.0826, 0.7426])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 100000
Density: 0.001
Time: 8.216149806976318 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '181643', '-ss', '10000', '-sd', '0.001', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 100000, "MATRIX_DENSITY": 0.001, "TIME_S": 10.058825254440308}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 10, 23, ..., 99984, 99996,
100000]),
col_indices=tensor([2026, 2065, 2399, ..., 4623, 7297, 9355]),
values=tensor([0.4157, 0.6883, 0.2119, ..., 0.3441, 0.2622, 0.5721]),
size=(10000, 10000), nnz=100000, layout=torch.sparse_csr)
tensor([0.4888, 0.3451, 0.6891, ..., 0.9797, 0.8702, 0.1612])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 100000
Density: 0.001
Time: 10.058825254440308 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 10, 23, ..., 99984, 99996,
100000]),
col_indices=tensor([2026, 2065, 2399, ..., 4623, 7297, 9355]),
values=tensor([0.4157, 0.6883, 0.2119, ..., 0.3441, 0.2622, 0.5721]),
size=(10000, 10000), nnz=100000, layout=torch.sparse_csr)
tensor([0.4888, 0.3451, 0.6891, ..., 0.9797, 0.8702, 0.1612])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 100000
Density: 0.001
Time: 10.058825254440308 seconds
[40.01, 39.91, 39.26, 39.32, 39.03, 38.69, 39.03, 38.68, 38.9, 38.67]
[108.0]
12.355550527572632
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 181643, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [10000, 10000], 'MATRIX_ROWS': 10000, 'MATRIX_SIZE': 100000000, 'MATRIX_NNZ': 100000, 'MATRIX_DENSITY': 0.001, 'TIME_S': 10.058825254440308, 'TIME_S_1KI': 0.05537689453730839, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 1334.3994569778442, 'W': 108.0}
[40.01, 39.91, 39.26, 39.32, 39.03, 38.69, 39.03, 38.68, 38.9, 38.67, 40.03, 39.23, 39.15, 39.23, 38.85, 38.69, 38.72, 38.72, 38.62, 38.62]
702.6950000000002
35.13475000000001
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 181643, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [10000, 10000], 'MATRIX_ROWS': 10000, 'MATRIX_SIZE': 100000000, 'MATRIX_NNZ': 100000, 'MATRIX_DENSITY': 0.001, 'TIME_S': 10.058825254440308, 'TIME_S_1KI': 0.05537689453730839, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 1334.3994569778442, 'W': 108.0, 'J_1KI': 7.346275149484671, 'W_1KI': 0.5945728709611711, 'W_D': 72.86524999999999, 'J_D': 900.2902780792116, 'W_D_1KI': 0.4011453785722543, 'J_D_1KI': 0.002208427401949177}

1
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_10000_0.01.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Epyc 7313P", "CORES": 16, "ITERATIONS": 104114, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 1000000, "MATRIX_DENSITY": 0.01, "TIME_S": 10.469164609909058, "TIME_S_1KI": 0.10055482077250953, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 1774.261237783432, "W": 135.86, "J_1KI": 17.041524077294426, "W_1KI": 1.304915765410992, "W_D": 100.35275000000001, "J_D": 1310.5549420725108, "W_D_1KI": 0.9638737345601938, "J_D_1KI": 0.009257868630157269}

105
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_10000_0.01.output Normal file
View File

@ -0,0 +1,105 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '1000', '-ss', '10000', '-sd', '0.01', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 1000000, "MATRIX_DENSITY": 0.01, "TIME_S": 0.14159297943115234}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 124, 236, ..., 999773,
999882, 1000000]),
col_indices=tensor([ 35, 69, 144, ..., 9773, 9862, 9873]),
values=tensor([0.1838, 0.7773, 0.5109, ..., 0.8192, 0.8376, 0.6812]),
size=(10000, 10000), nnz=1000000, layout=torch.sparse_csr)
tensor([0.0358, 0.2032, 0.7087, ..., 0.4931, 0.1706, 0.1726])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 1000000
Density: 0.01
Time: 0.14159297943115234 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '74156', '-ss', '10000', '-sd', '0.01', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 1000000, "MATRIX_DENSITY": 0.01, "TIME_S": 7.9134438037872314}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 93, 199, ..., 999798,
999892, 1000000]),
col_indices=tensor([ 57, 323, 325, ..., 9719, 9779, 9889]),
values=tensor([0.3339, 0.1610, 0.8675, ..., 0.7107, 0.3615, 0.1870]),
size=(10000, 10000), nnz=1000000, layout=torch.sparse_csr)
tensor([0.9536, 0.3002, 0.1616, ..., 0.3121, 0.8413, 0.9505])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 1000000
Density: 0.01
Time: 7.9134438037872314 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '98394', '-ss', '10000', '-sd', '0.01', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 1000000, "MATRIX_DENSITY": 0.01, "TIME_S": 9.923112392425537}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 97, 191, ..., 999779,
999891, 1000000]),
col_indices=tensor([ 18, 52, 269, ..., 9883, 9995, 9999]),
values=tensor([0.5511, 0.2767, 0.8168, ..., 0.6887, 0.5827, 0.0686]),
size=(10000, 10000), nnz=1000000, layout=torch.sparse_csr)
tensor([0.2767, 0.4380, 0.7945, ..., 0.2102, 0.5547, 0.8740])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 1000000
Density: 0.01
Time: 9.923112392425537 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '104114', '-ss', '10000', '-sd', '0.01', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 1000000, "MATRIX_DENSITY": 0.01, "TIME_S": 10.469164609909058}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 112, 221, ..., 999805,
999915, 1000000]),
col_indices=tensor([ 402, 501, 665, ..., 9291, 9326, 9607]),
values=tensor([0.0486, 0.5637, 0.4384, ..., 0.7973, 0.3634, 0.8351]),
size=(10000, 10000), nnz=1000000, layout=torch.sparse_csr)
tensor([0.7936, 0.9785, 0.9590, ..., 0.6005, 0.0137, 0.6516])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 1000000
Density: 0.01
Time: 10.469164609909058 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 112, 221, ..., 999805,
999915, 1000000]),
col_indices=tensor([ 402, 501, 665, ..., 9291, 9326, 9607]),
values=tensor([0.0486, 0.5637, 0.4384, ..., 0.7973, 0.3634, 0.8351]),
size=(10000, 10000), nnz=1000000, layout=torch.sparse_csr)
tensor([0.7936, 0.9785, 0.9590, ..., 0.6005, 0.0137, 0.6516])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 1000000
Density: 0.01
Time: 10.469164609909058 seconds
[42.04, 39.8, 39.79, 39.52, 39.3, 39.73, 39.12, 39.49, 39.14, 38.98]
[135.86]
13.059482097625732
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 104114, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [10000, 10000], 'MATRIX_ROWS': 10000, 'MATRIX_SIZE': 100000000, 'MATRIX_NNZ': 1000000, 'MATRIX_DENSITY': 0.01, 'TIME_S': 10.469164609909058, 'TIME_S_1KI': 0.10055482077250953, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 1774.261237783432, 'W': 135.86}
[42.04, 39.8, 39.79, 39.52, 39.3, 39.73, 39.12, 39.49, 39.14, 38.98, 39.91, 39.55, 39.06, 39.42, 39.43, 39.34, 38.96, 39.36, 38.94, 39.46]
710.145
35.50725
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 104114, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [10000, 10000], 'MATRIX_ROWS': 10000, 'MATRIX_SIZE': 100000000, 'MATRIX_NNZ': 1000000, 'MATRIX_DENSITY': 0.01, 'TIME_S': 10.469164609909058, 'TIME_S_1KI': 0.10055482077250953, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 1774.261237783432, 'W': 135.86, 'J_1KI': 17.041524077294426, 'W_1KI': 1.304915765410992, 'W_D': 100.35275000000001, 'J_D': 1310.5549420725108, 'W_D_1KI': 0.9638737345601938, 'J_D_1KI': 0.009257868630157269}

1
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_10000_0.05.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Epyc 7313P", "CORES": 16, "ITERATIONS": 27894, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 5000000, "MATRIX_DENSITY": 0.05, "TIME_S": 10.822905540466309, "TIME_S_1KI": 0.3880012024258374, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 2101.6757108688353, "W": 151.95, "J_1KI": 75.34508176915593, "W_1KI": 5.447408044740804, "W_D": 116.03349999999999, "J_D": 1604.90153732872, "W_D_1KI": 4.159801390980138, "J_D_1KI": 0.14912889477952743}

85
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_10000_0.05.output Normal file
View File

@ -0,0 +1,85 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '1000', '-ss', '10000', '-sd', '0.05', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 5000000, "MATRIX_DENSITY": 0.05, "TIME_S": 0.4579291343688965}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 485, 1001, ..., 4998993,
4999541, 5000000]),
col_indices=tensor([ 5, 20, 61, ..., 9897, 9942, 9998]),
values=tensor([0.7241, 0.0945, 0.6836, ..., 0.9220, 0.2796, 0.2745]),
size=(10000, 10000), nnz=5000000, layout=torch.sparse_csr)
tensor([0.6528, 0.9454, 0.7224, ..., 0.5670, 0.2826, 0.8750])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 5000000
Density: 0.05
Time: 0.4579291343688965 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '22929', '-ss', '10000', '-sd', '0.05', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 5000000, "MATRIX_DENSITY": 0.05, "TIME_S": 8.630967855453491}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 483, 987, ..., 4998961,
4999465, 5000000]),
col_indices=tensor([ 47, 67, 96, ..., 9993, 9994, 9997]),
values=tensor([0.9705, 0.3882, 0.2458, ..., 0.5796, 0.8899, 0.6056]),
size=(10000, 10000), nnz=5000000, layout=torch.sparse_csr)
tensor([0.2409, 0.7584, 0.7571, ..., 0.5444, 0.5564, 0.6333])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 5000000
Density: 0.05
Time: 8.630967855453491 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '27894', '-ss', '10000', '-sd', '0.05', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 5000000, "MATRIX_DENSITY": 0.05, "TIME_S": 10.822905540466309}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 505, 994, ..., 4999000,
4999548, 5000000]),
col_indices=tensor([ 26, 89, 94, ..., 9963, 9967, 9969]),
values=tensor([0.5738, 0.3729, 0.9664, ..., 0.7914, 0.9130, 0.5932]),
size=(10000, 10000), nnz=5000000, layout=torch.sparse_csr)
tensor([0.2560, 0.0745, 0.3692, ..., 0.2024, 0.4618, 0.6540])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 5000000
Density: 0.05
Time: 10.822905540466309 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 505, 994, ..., 4999000,
4999548, 5000000]),
col_indices=tensor([ 26, 89, 94, ..., 9963, 9967, 9969]),
values=tensor([0.5738, 0.3729, 0.9664, ..., 0.7914, 0.9130, 0.5932]),
size=(10000, 10000), nnz=5000000, layout=torch.sparse_csr)
tensor([0.2560, 0.0745, 0.3692, ..., 0.2024, 0.4618, 0.6540])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 5000000
Density: 0.05
Time: 10.822905540466309 seconds
[41.38, 40.1, 39.88, 40.17, 39.72, 39.62, 39.69, 39.64, 39.9, 39.73]
[151.95]
13.831363677978516
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 27894, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [10000, 10000], 'MATRIX_ROWS': 10000, 'MATRIX_SIZE': 100000000, 'MATRIX_NNZ': 5000000, 'MATRIX_DENSITY': 0.05, 'TIME_S': 10.822905540466309, 'TIME_S_1KI': 0.3880012024258374, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 2101.6757108688353, 'W': 151.95}
[41.38, 40.1, 39.88, 40.17, 39.72, 39.62, 39.69, 39.64, 39.9, 39.73, 40.26, 39.63, 39.55, 39.93, 41.22, 40.33, 39.48, 39.56, 39.48, 39.49]
718.3299999999999
35.9165
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 27894, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [10000, 10000], 'MATRIX_ROWS': 10000, 'MATRIX_SIZE': 100000000, 'MATRIX_NNZ': 5000000, 'MATRIX_DENSITY': 0.05, 'TIME_S': 10.822905540466309, 'TIME_S_1KI': 0.3880012024258374, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 2101.6757108688353, 'W': 151.95, 'J_1KI': 75.34508176915593, 'W_1KI': 5.447408044740804, 'W_D': 116.03349999999999, 'J_D': 1604.90153732872, 'W_D_1KI': 4.159801390980138, 'J_D_1KI': 0.14912889477952743}

1
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_10000_0.1.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Epyc 7313P", "CORES": 16, "ITERATIONS": 4679, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 10000000, "MATRIX_DENSITY": 0.1, "TIME_S": 11.427535057067871, "TIME_S_1KI": 2.4423028546843066, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 1873.982270450592, "W": 124.72, "J_1KI": 400.5091409383612, "W_1KI": 26.655268219705064, "W_D": 88.71, "J_D": 1332.9134638524054, "W_D_1KI": 18.959179311818765, "J_D_1KI": 4.051972496648593}

85
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_10000_0.1.output Normal file
View File

@ -0,0 +1,85 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '1000', '-ss', '10000', '-sd', '0.1', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 10000000, "MATRIX_DENSITY": 0.1, "TIME_S": 2.382111072540283}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 1024, 2032, ..., 9997994,
9998974, 10000000]),
col_indices=tensor([ 25, 59, 80, ..., 9969, 9975, 9986]),
values=tensor([0.6759, 0.5147, 0.7066, ..., 0.5276, 0.4088, 0.2550]),
size=(10000, 10000), nnz=10000000, layout=torch.sparse_csr)
tensor([0.6863, 0.6243, 0.0191, ..., 0.9166, 0.1487, 0.8503])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 10000000
Density: 0.1
Time: 2.382111072540283 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '4407', '-ss', '10000', '-sd', '0.1', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 10000000, "MATRIX_DENSITY": 0.1, "TIME_S": 9.887728929519653}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 980, 2002, ..., 9998027,
9998983, 10000000]),
col_indices=tensor([ 0, 5, 25, ..., 9979, 9984, 9986]),
values=tensor([0.6732, 0.9055, 0.4649, ..., 0.1468, 0.7629, 0.6148]),
size=(10000, 10000), nnz=10000000, layout=torch.sparse_csr)
tensor([0.4732, 0.0327, 0.4956, ..., 0.7189, 0.9869, 0.4026])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 10000000
Density: 0.1
Time: 9.887728929519653 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '4679', '-ss', '10000', '-sd', '0.1', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 10000000, "MATRIX_DENSITY": 0.1, "TIME_S": 11.427535057067871}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 1053, 2097, ..., 9998095,
9999109, 10000000]),
col_indices=tensor([ 10, 15, 24, ..., 9977, 9991, 9995]),
values=tensor([0.4155, 0.1468, 0.0149, ..., 0.0226, 0.9383, 0.4708]),
size=(10000, 10000), nnz=10000000, layout=torch.sparse_csr)
tensor([0.3975, 0.8045, 0.4645, ..., 0.1781, 0.4097, 0.1046])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 10000000
Density: 0.1
Time: 11.427535057067871 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 1053, 2097, ..., 9998095,
9999109, 10000000]),
col_indices=tensor([ 10, 15, 24, ..., 9977, 9991, 9995]),
values=tensor([0.4155, 0.1468, 0.0149, ..., 0.0226, 0.9383, 0.4708]),
size=(10000, 10000), nnz=10000000, layout=torch.sparse_csr)
tensor([0.3975, 0.8045, 0.4645, ..., 0.1781, 0.4097, 0.1046])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 10000000
Density: 0.1
Time: 11.427535057067871 seconds
[40.62, 41.67, 40.6, 39.62, 39.77, 39.59, 39.62, 40.85, 40.24, 40.01]
[124.72]
15.02551531791687
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 4679, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [10000, 10000], 'MATRIX_ROWS': 10000, 'MATRIX_SIZE': 100000000, 'MATRIX_NNZ': 10000000, 'MATRIX_DENSITY': 0.1, 'TIME_S': 11.427535057067871, 'TIME_S_1KI': 2.4423028546843066, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 1873.982270450592, 'W': 124.72}
[40.62, 41.67, 40.6, 39.62, 39.77, 39.59, 39.62, 40.85, 40.24, 40.01, 40.22, 39.64, 40.11, 39.47, 39.58, 39.84, 39.97, 39.93, 39.51, 39.53]
720.2
36.010000000000005
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 4679, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [10000, 10000], 'MATRIX_ROWS': 10000, 'MATRIX_SIZE': 100000000, 'MATRIX_NNZ': 10000000, 'MATRIX_DENSITY': 0.1, 'TIME_S': 11.427535057067871, 'TIME_S_1KI': 2.4423028546843066, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 1873.982270450592, 'W': 124.72, 'J_1KI': 400.5091409383612, 'W_1KI': 26.655268219705064, 'W_D': 88.71, 'J_D': 1332.9134638524054, 'W_D_1KI': 18.959179311818765, 'J_D_1KI': 4.051972496648593}

1
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_10000_0.2.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Epyc 7313P", "CORES": 16, "ITERATIONS": 2251, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 20000000, "MATRIX_DENSITY": 0.2, "TIME_S": 10.887785911560059, "TIME_S_1KI": 4.83686624236342, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 2027.23151884079, "W": 120.43, "J_1KI": 900.591523252239, "W_1KI": 53.500666370501996, "W_D": 84.27900000000001, "J_D": 1418.6917311000825, "W_D_1KI": 37.44069302532208, "J_D_1KI": 16.632915604319006}

85
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_10000_0.2.output Normal file
View File

@ -0,0 +1,85 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '1000', '-ss', '10000', '-sd', '0.2', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 20000000, "MATRIX_DENSITY": 0.2, "TIME_S": 4.959461212158203}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 1995, 4040, ..., 19996024,
19998015, 20000000]),
col_indices=tensor([ 0, 11, 12, ..., 9985, 9992, 9995]),
values=tensor([0.1207, 0.1695, 0.9340, ..., 0.6555, 0.7804, 0.2569]),
size=(10000, 10000), nnz=20000000, layout=torch.sparse_csr)
tensor([0.9596, 0.9534, 0.3471, ..., 0.1162, 0.8421, 0.0589])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 20000000
Density: 0.2
Time: 4.959461212158203 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '2117', '-ss', '10000', '-sd', '0.2', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 20000000, "MATRIX_DENSITY": 0.2, "TIME_S": 9.870691061019897}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 2060, 4088, ..., 19995982,
19997996, 20000000]),
col_indices=tensor([ 3, 8, 18, ..., 9972, 9995, 9999]),
values=tensor([0.9088, 0.2769, 0.7723, ..., 0.9463, 0.8275, 0.8743]),
size=(10000, 10000), nnz=20000000, layout=torch.sparse_csr)
tensor([0.1663, 0.5238, 0.4734, ..., 0.4751, 0.9551, 0.4862])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 20000000
Density: 0.2
Time: 9.870691061019897 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '2251', '-ss', '10000', '-sd', '0.2', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 20000000, "MATRIX_DENSITY": 0.2, "TIME_S": 10.887785911560059}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 1987, 4056, ..., 19996028,
19998022, 20000000]),
col_indices=tensor([ 5, 19, 20, ..., 9991, 9993, 9995]),
values=tensor([0.9673, 0.5215, 0.1097, ..., 0.0767, 0.9506, 0.8361]),
size=(10000, 10000), nnz=20000000, layout=torch.sparse_csr)
tensor([0.1308, 0.6150, 0.9184, ..., 0.0574, 0.4962, 0.6674])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 20000000
Density: 0.2
Time: 10.887785911560059 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 1987, 4056, ..., 19996028,
19998022, 20000000]),
col_indices=tensor([ 5, 19, 20, ..., 9991, 9993, 9995]),
values=tensor([0.9673, 0.5215, 0.1097, ..., 0.0767, 0.9506, 0.8361]),
size=(10000, 10000), nnz=20000000, layout=torch.sparse_csr)
tensor([0.1308, 0.6150, 0.9184, ..., 0.0574, 0.4962, 0.6674])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 20000000
Density: 0.2
Time: 10.887785911560059 seconds
[40.74, 39.87, 40.58, 40.31, 40.56, 40.27, 40.45, 40.39, 39.9, 40.0]
[120.43]
16.833276748657227
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 2251, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [10000, 10000], 'MATRIX_ROWS': 10000, 'MATRIX_SIZE': 100000000, 'MATRIX_NNZ': 20000000, 'MATRIX_DENSITY': 0.2, 'TIME_S': 10.887785911560059, 'TIME_S_1KI': 4.83686624236342, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 2027.23151884079, 'W': 120.43}
[40.74, 39.87, 40.58, 40.31, 40.56, 40.27, 40.45, 40.39, 39.9, 40.0, 40.84, 39.74, 40.34, 40.47, 40.2, 40.2, 39.72, 39.73, 39.66, 39.68]
723.02
36.150999999999996
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 2251, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [10000, 10000], 'MATRIX_ROWS': 10000, 'MATRIX_SIZE': 100000000, 'MATRIX_NNZ': 20000000, 'MATRIX_DENSITY': 0.2, 'TIME_S': 10.887785911560059, 'TIME_S_1KI': 4.83686624236342, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 2027.23151884079, 'W': 120.43, 'J_1KI': 900.591523252239, 'W_1KI': 53.500666370501996, 'W_D': 84.27900000000001, 'J_D': 1418.6917311000825, 'W_D_1KI': 37.44069302532208, 'J_D_1KI': 16.632915604319006}

1
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_10000_0.3.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Epyc 7313P", "CORES": 16, "ITERATIONS": 1475, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 30000000, "MATRIX_DENSITY": 0.3, "TIME_S": 10.550647735595703, "TIME_S_1KI": 7.152981515658104, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 2246.3171599555017, "W": 116.09, "J_1KI": 1522.9268881054247, "W_1KI": 78.7050847457627, "W_D": 80.02975, "J_D": 1548.5588830385805, "W_D_1KI": 54.25745762711865, "J_D_1KI": 36.78471703533467}

65
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_10000_0.3.output Normal file
View File

@ -0,0 +1,65 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '1000', '-ss', '10000', '-sd', '0.3', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 30000000, "MATRIX_DENSITY": 0.3, "TIME_S": 7.117977619171143}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 2996, 5947, ..., 29993941,
29997016, 30000000]),
col_indices=tensor([ 2, 4, 5, ..., 9994, 9995, 9997]),
values=tensor([0.7643, 0.7440, 0.4862, ..., 0.6436, 0.3641, 0.9418]),
size=(10000, 10000), nnz=30000000, layout=torch.sparse_csr)
tensor([0.8566, 0.8595, 0.2293, ..., 0.0057, 0.7338, 0.0583])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 30000000
Density: 0.3
Time: 7.117977619171143 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '1475', '-ss', '10000', '-sd', '0.3', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 30000000, "MATRIX_DENSITY": 0.3, "TIME_S": 10.550647735595703}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 2975, 5983, ..., 29994011,
29997029, 30000000]),
col_indices=tensor([ 7, 9, 13, ..., 9994, 9995, 9998]),
values=tensor([0.9780, 0.9139, 0.8008, ..., 0.7340, 0.6785, 0.0713]),
size=(10000, 10000), nnz=30000000, layout=torch.sparse_csr)
tensor([0.9158, 0.5873, 0.3730, ..., 0.5358, 0.1305, 0.5051])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 30000000
Density: 0.3
Time: 10.550647735595703 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 2975, 5983, ..., 29994011,
29997029, 30000000]),
col_indices=tensor([ 7, 9, 13, ..., 9994, 9995, 9998]),
values=tensor([0.9780, 0.9139, 0.8008, ..., 0.7340, 0.6785, 0.0713]),
size=(10000, 10000), nnz=30000000, layout=torch.sparse_csr)
tensor([0.9158, 0.5873, 0.3730, ..., 0.5358, 0.1305, 0.5051])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 30000000
Density: 0.3
Time: 10.550647735595703 seconds
[41.39, 39.87, 39.86, 40.02, 39.88, 39.87, 40.22, 40.42, 40.2, 40.31]
[116.09]
19.349790334701538
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 1475, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [10000, 10000], 'MATRIX_ROWS': 10000, 'MATRIX_SIZE': 100000000, 'MATRIX_NNZ': 30000000, 'MATRIX_DENSITY': 0.3, 'TIME_S': 10.550647735595703, 'TIME_S_1KI': 7.152981515658104, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 2246.3171599555017, 'W': 116.09}
[41.39, 39.87, 39.86, 40.02, 39.88, 39.87, 40.22, 40.42, 40.2, 40.31, 41.51, 39.76, 39.79, 39.7, 39.79, 40.38, 40.29, 39.67, 39.96, 39.84]
721.2049999999999
36.060249999999996
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 1475, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [10000, 10000], 'MATRIX_ROWS': 10000, 'MATRIX_SIZE': 100000000, 'MATRIX_NNZ': 30000000, 'MATRIX_DENSITY': 0.3, 'TIME_S': 10.550647735595703, 'TIME_S_1KI': 7.152981515658104, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 2246.3171599555017, 'W': 116.09, 'J_1KI': 1522.9268881054247, 'W_1KI': 78.7050847457627, 'W_D': 80.02975, 'J_D': 1548.5588830385805, 'W_D_1KI': 54.25745762711865, 'J_D_1KI': 36.78471703533467}

1
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_10000_1e-05.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Epyc 7313P", "CORES": 16, "ITERATIONS": 355068, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 1000, "MATRIX_DENSITY": 1e-05, "TIME_S": 10.454679489135742, "TIME_S_1KI": 0.029444161369472165, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 1283.4049695920944, "W": 97.06, "J_1KI": 3.614532905224054, "W_1KI": 0.27335608953777873, "W_D": 61.48125, "J_D": 812.9542735084892, "W_D_1KI": 0.17315345229646154, "J_D_1KI": 0.0004876627921875853}

1414
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_10000_1e-05.output Normal file
View File

File diff suppressed because it is too large Load Diff

1
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_10000_5e-05.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Epyc 7313P", "CORES": 16, "ITERATIONS": 307566, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 5000, "MATRIX_DENSITY": 5e-05, "TIME_S": 10.194913387298584, "TIME_S_1KI": 0.033147075383165185, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 1254.457565395832, "W": 97.91, "J_1KI": 4.078661378032136, "W_1KI": 0.3183381778219959, "W_D": 62.19175, "J_D": 796.8227075141073, "W_D_1KI": 0.2022061931422849, "J_D_1KI": 0.0006574400068352317}

81
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_10000_5e-05.output Normal file
View File

@ -0,0 +1,81 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '1000', '-ss', '10000', '-sd', '5e-05', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 5000, "MATRIX_DENSITY": 5e-05, "TIME_S": 0.04550504684448242}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 0, 0, ..., 4998, 5000, 5000]),
col_indices=tensor([9281, 526, 5110, ..., 4172, 680, 4833]),
values=tensor([0.9710, 0.4177, 0.1273, ..., 0.7621, 0.2431, 0.8030]),
size=(10000, 10000), nnz=5000, layout=torch.sparse_csr)
tensor([0.6244, 0.3231, 0.3638, ..., 0.2586, 0.1943, 0.4038])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 5000
Density: 5e-05
Time: 0.04550504684448242 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '230743', '-ss', '10000', '-sd', '5e-05', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 5000, "MATRIX_DENSITY": 5e-05, "TIME_S": 7.877320289611816}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 1, 1, ..., 4996, 4999, 5000]),
col_indices=tensor([5149, 830, 3827, ..., 6947, 7825, 8143]),
values=tensor([0.7974, 0.8672, 0.6352, ..., 0.0945, 0.9729, 0.8206]),
size=(10000, 10000), nnz=5000, layout=torch.sparse_csr)
tensor([0.8724, 0.1762, 0.3345, ..., 0.8958, 0.7321, 0.5036])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 5000
Density: 5e-05
Time: 7.877320289611816 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '307566', '-ss', '10000', '-sd', '5e-05', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [10000, 10000], "MATRIX_ROWS": 10000, "MATRIX_SIZE": 100000000, "MATRIX_NNZ": 5000, "MATRIX_DENSITY": 5e-05, "TIME_S": 10.194913387298584}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 0, 1, ..., 5000, 5000, 5000]),
col_indices=tensor([6013, 2562, 3841, ..., 8262, 3270, 1424]),
values=tensor([0.2685, 0.3885, 0.6243, ..., 0.1198, 0.9466, 0.9233]),
size=(10000, 10000), nnz=5000, layout=torch.sparse_csr)
tensor([0.2690, 0.9597, 0.8597, ..., 0.6996, 0.9887, 0.3737])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 5000
Density: 5e-05
Time: 10.194913387298584 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 0, 1, ..., 5000, 5000, 5000]),
col_indices=tensor([6013, 2562, 3841, ..., 8262, 3270, 1424]),
values=tensor([0.2685, 0.3885, 0.6243, ..., 0.1198, 0.9466, 0.9233]),
size=(10000, 10000), nnz=5000, layout=torch.sparse_csr)
tensor([0.2690, 0.9597, 0.8597, ..., 0.6996, 0.9887, 0.3737])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([10000, 10000])
Rows: 10000
Size: 100000000
NNZ: 5000
Density: 5e-05
Time: 10.194913387298584 seconds
[40.9, 39.57, 39.65, 39.48, 39.52, 39.37, 39.42, 39.88, 40.21, 39.84]
[97.91]
12.81235384941101
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 307566, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [10000, 10000], 'MATRIX_ROWS': 10000, 'MATRIX_SIZE': 100000000, 'MATRIX_NNZ': 5000, 'MATRIX_DENSITY': 5e-05, 'TIME_S': 10.194913387298584, 'TIME_S_1KI': 0.033147075383165185, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 1254.457565395832, 'W': 97.91}
[40.9, 39.57, 39.65, 39.48, 39.52, 39.37, 39.42, 39.88, 40.21, 39.84, 41.61, 39.93, 39.26, 40.39, 39.17, 39.17, 39.39, 39.38, 39.35, 40.1]
714.365
35.71825
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 307566, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [10000, 10000], 'MATRIX_ROWS': 10000, 'MATRIX_SIZE': 100000000, 'MATRIX_NNZ': 5000, 'MATRIX_DENSITY': 5e-05, 'TIME_S': 10.194913387298584, 'TIME_S_1KI': 0.033147075383165185, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 1254.457565395832, 'W': 97.91, 'J_1KI': 4.078661378032136, 'W_1KI': 0.3183381778219959, 'W_D': 62.19175, 'J_D': 796.8227075141073, 'W_D_1KI': 0.2022061931422849, 'J_D_1KI': 0.0006574400068352317}

1
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_500000_0.0001.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Epyc 7313P", "CORES": 16, "ITERATIONS": 1316, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [500000, 500000], "MATRIX_ROWS": 500000, "MATRIX_SIZE": 250000000000, "MATRIX_NNZ": 25000000, "MATRIX_DENSITY": 0.0001, "TIME_S": 10.480877876281738, "TIME_S_1KI": 7.964192915107703, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 2349.371359462738, "W": 119.72, "J_1KI": 1785.2365953364272, "W_1KI": 90.9726443768997, "W_D": 83.6515, "J_D": 1641.5673093559742, "W_D_1KI": 63.564969604863215, "J_D_1KI": 48.3016486359143}

89
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_500000_0.0001.output Normal file
View File

@ -0,0 +1,89 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '1000', '-ss', '500000', '-sd', '0.0001', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [500000, 500000], "MATRIX_ROWS": 500000, "MATRIX_SIZE": 250000000000, "MATRIX_NNZ": 25000000, "MATRIX_DENSITY": 0.0001, "TIME_S": 8.476217031478882}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 58, 110, ..., 24999904,
24999948, 25000000]),
col_indices=tensor([ 6107, 36475, 44542, ..., 455197, 482838,
484709]),
values=tensor([0.8741, 0.1087, 0.7265, ..., 0.9387, 0.2139, 0.8984]),
size=(500000, 500000), nnz=25000000, layout=torch.sparse_csr)
tensor([0.2008, 0.1464, 0.5363, ..., 0.5258, 0.1478, 0.0153])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([500000, 500000])
Rows: 500000
Size: 250000000000
NNZ: 25000000
Density: 0.0001
Time: 8.476217031478882 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '1238', '-ss', '500000', '-sd', '0.0001', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [500000, 500000], "MATRIX_ROWS": 500000, "MATRIX_SIZE": 250000000000, "MATRIX_NNZ": 25000000, "MATRIX_DENSITY": 0.0001, "TIME_S": 9.872223138809204}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 42, 103, ..., 24999895,
24999951, 25000000]),
col_indices=tensor([ 1782, 32597, 35292, ..., 490788, 494408,
495086]),
values=tensor([0.7532, 0.4055, 0.7849, ..., 0.0826, 0.2837, 0.9366]),
size=(500000, 500000), nnz=25000000, layout=torch.sparse_csr)
tensor([0.6389, 0.8135, 0.6286, ..., 0.0387, 0.4513, 0.2151])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([500000, 500000])
Rows: 500000
Size: 250000000000
NNZ: 25000000
Density: 0.0001
Time: 9.872223138809204 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '1316', '-ss', '500000', '-sd', '0.0001', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [500000, 500000], "MATRIX_ROWS": 500000, "MATRIX_SIZE": 250000000000, "MATRIX_NNZ": 25000000, "MATRIX_DENSITY": 0.0001, "TIME_S": 10.480877876281738}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 49, 93, ..., 24999907,
24999956, 25000000]),
col_indices=tensor([ 1315, 9605, 36829, ..., 467295, 483577,
490282]),
values=tensor([0.4504, 0.6377, 0.8962, ..., 0.8735, 0.2973, 0.1824]),
size=(500000, 500000), nnz=25000000, layout=torch.sparse_csr)
tensor([0.1673, 0.3950, 0.6065, ..., 0.2020, 0.8580, 0.9739])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([500000, 500000])
Rows: 500000
Size: 250000000000
NNZ: 25000000
Density: 0.0001
Time: 10.480877876281738 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 49, 93, ..., 24999907,
24999956, 25000000]),
col_indices=tensor([ 1315, 9605, 36829, ..., 467295, 483577,
490282]),
values=tensor([0.4504, 0.6377, 0.8962, ..., 0.8735, 0.2973, 0.1824]),
size=(500000, 500000), nnz=25000000, layout=torch.sparse_csr)
tensor([0.1673, 0.3950, 0.6065, ..., 0.2020, 0.8580, 0.9739])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([500000, 500000])
Rows: 500000
Size: 250000000000
NNZ: 25000000
Density: 0.0001
Time: 10.480877876281738 seconds
[40.78, 40.23, 40.39, 40.14, 40.33, 40.17, 39.83, 39.85, 39.79, 39.68]
[119.72]
19.623883724212646
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 1316, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [500000, 500000], 'MATRIX_ROWS': 500000, 'MATRIX_SIZE': 250000000000, 'MATRIX_NNZ': 25000000, 'MATRIX_DENSITY': 0.0001, 'TIME_S': 10.480877876281738, 'TIME_S_1KI': 7.964192915107703, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 2349.371359462738, 'W': 119.72}
[40.78, 40.23, 40.39, 40.14, 40.33, 40.17, 39.83, 39.85, 39.79, 39.68, 41.19, 39.75, 40.31, 41.27, 39.67, 39.76, 39.72, 39.58, 39.67, 40.17]
721.3699999999999
36.06849999999999
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 1316, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [500000, 500000], 'MATRIX_ROWS': 500000, 'MATRIX_SIZE': 250000000000, 'MATRIX_NNZ': 25000000, 'MATRIX_DENSITY': 0.0001, 'TIME_S': 10.480877876281738, 'TIME_S_1KI': 7.964192915107703, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 2349.371359462738, 'W': 119.72, 'J_1KI': 1785.2365953364272, 'W_1KI': 90.9726443768997, 'W_D': 83.6515, 'J_D': 1641.5673093559742, 'W_D_1KI': 63.564969604863215, 'J_D_1KI': 48.3016486359143}

1
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_500000_1e-05.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Epyc 7313P", "CORES": 16, "ITERATIONS": 21497, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [500000, 500000], "MATRIX_ROWS": 500000, "MATRIX_SIZE": 250000000000, "MATRIX_NNZ": 2500000, "MATRIX_DENSITY": 1e-05, "TIME_S": 10.492619514465332, "TIME_S_1KI": 0.488096921173435, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 2075.744820713997, "W": 155.25, "J_1KI": 96.55974418356035, "W_1KI": 7.221937944829511, "W_D": 119.6075, "J_D": 1599.1925838553905, "W_D_1KI": 5.5639158952411965, "J_D_1KI": 0.25882290064851826}

89
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_500000_1e-05.output Normal file
View File

@ -0,0 +1,89 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '1000', '-ss', '500000', '-sd', '1e-05', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [500000, 500000], "MATRIX_ROWS": 500000, "MATRIX_SIZE": 250000000000, "MATRIX_NNZ": 2500000, "MATRIX_DENSITY": 1e-05, "TIME_S": 0.5443899631500244}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 7, 13, ..., 2499984,
2499993, 2500000]),
col_indices=tensor([ 29642, 73796, 205405, ..., 362365, 387524,
440531]),
values=tensor([0.6565, 0.4150, 0.8341, ..., 0.7997, 0.8212, 0.8706]),
size=(500000, 500000), nnz=2500000, layout=torch.sparse_csr)
tensor([0.3188, 0.4041, 0.2486, ..., 0.5189, 0.6175, 0.2446])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([500000, 500000])
Rows: 500000
Size: 250000000000
NNZ: 2500000
Density: 1e-05
Time: 0.5443899631500244 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '19287', '-ss', '500000', '-sd', '1e-05', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [500000, 500000], "MATRIX_ROWS": 500000, "MATRIX_SIZE": 250000000000, "MATRIX_NNZ": 2500000, "MATRIX_DENSITY": 1e-05, "TIME_S": 9.420541286468506}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 4, 12, ..., 2499994,
2499998, 2500000]),
col_indices=tensor([131466, 192610, 285983, ..., 398857, 7127,
216070]),
values=tensor([0.3766, 0.1095, 0.0818, ..., 0.7673, 0.9998, 0.7256]),
size=(500000, 500000), nnz=2500000, layout=torch.sparse_csr)
tensor([0.6672, 0.9862, 0.6354, ..., 0.4943, 0.9100, 0.2548])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([500000, 500000])
Rows: 500000
Size: 250000000000
NNZ: 2500000
Density: 1e-05
Time: 9.420541286468506 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '21497', '-ss', '500000', '-sd', '1e-05', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [500000, 500000], "MATRIX_ROWS": 500000, "MATRIX_SIZE": 250000000000, "MATRIX_NNZ": 2500000, "MATRIX_DENSITY": 1e-05, "TIME_S": 10.492619514465332}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 10, 12, ..., 2499992,
2499996, 2500000]),
col_indices=tensor([124091, 157764, 160136, ..., 120950, 171105,
490445]),
values=tensor([0.1739, 0.8424, 0.0842, ..., 0.2028, 0.9911, 0.7243]),
size=(500000, 500000), nnz=2500000, layout=torch.sparse_csr)
tensor([0.9645, 0.6044, 0.9036, ..., 0.9779, 0.7664, 0.8298])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([500000, 500000])
Rows: 500000
Size: 250000000000
NNZ: 2500000
Density: 1e-05
Time: 10.492619514465332 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 10, 12, ..., 2499992,
2499996, 2500000]),
col_indices=tensor([124091, 157764, 160136, ..., 120950, 171105,
490445]),
values=tensor([0.1739, 0.8424, 0.0842, ..., 0.2028, 0.9911, 0.7243]),
size=(500000, 500000), nnz=2500000, layout=torch.sparse_csr)
tensor([0.9645, 0.6044, 0.9036, ..., 0.9779, 0.7664, 0.8298])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([500000, 500000])
Rows: 500000
Size: 250000000000
NNZ: 2500000
Density: 1e-05
Time: 10.492619514465332 seconds
[41.35, 39.34, 39.96, 39.31, 39.6, 39.93, 39.84, 39.39, 39.3, 39.31]
[155.25]
13.370337009429932
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 21497, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [500000, 500000], 'MATRIX_ROWS': 500000, 'MATRIX_SIZE': 250000000000, 'MATRIX_NNZ': 2500000, 'MATRIX_DENSITY': 1e-05, 'TIME_S': 10.492619514465332, 'TIME_S_1KI': 0.488096921173435, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 2075.744820713997, 'W': 155.25}
[41.35, 39.34, 39.96, 39.31, 39.6, 39.93, 39.84, 39.39, 39.3, 39.31, 40.05, 40.08, 39.33, 39.83, 39.32, 39.88, 39.28, 39.25, 39.29, 39.13]
712.85
35.6425
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 21497, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [500000, 500000], 'MATRIX_ROWS': 500000, 'MATRIX_SIZE': 250000000000, 'MATRIX_NNZ': 2500000, 'MATRIX_DENSITY': 1e-05, 'TIME_S': 10.492619514465332, 'TIME_S_1KI': 0.488096921173435, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 2075.744820713997, 'W': 155.25, 'J_1KI': 96.55974418356035, 'W_1KI': 7.221937944829511, 'W_D': 119.6075, 'J_D': 1599.1925838553905, 'W_D_1KI': 5.5639158952411965, 'J_D_1KI': 0.25882290064851826}

1
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_500000_5e-05.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Epyc 7313P", "CORES": 16, "ITERATIONS": 2443, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [500000, 500000], "MATRIX_ROWS": 500000, "MATRIX_SIZE": 250000000000, "MATRIX_NNZ": 12500000, "MATRIX_DENSITY": 5e-05, "TIME_S": 11.091211557388306, "TIME_S_1KI": 4.5399965441622205, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 2093.1614422798157, "W": 125.74, "J_1KI": 856.7996079737272, "W_1KI": 51.469504707327054, "W_D": 89.3905, "J_D": 1488.0606641173363, "W_D_1KI": 36.59046254604994, "J_D_1KI": 14.977676031948402}

89
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_500000_5e-05.output Normal file
View File

@ -0,0 +1,89 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '1000', '-ss', '500000', '-sd', '5e-05', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [500000, 500000], "MATRIX_ROWS": 500000, "MATRIX_SIZE": 250000000000, "MATRIX_NNZ": 12500000, "MATRIX_DENSITY": 5e-05, "TIME_S": 4.620434761047363}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 28, 55, ..., 12499942,
12499972, 12500000]),
col_indices=tensor([ 19855, 24177, 33309, ..., 430292, 468270,
470726]),
values=tensor([0.1735, 0.2720, 0.9086, ..., 0.2697, 0.0473, 0.0416]),
size=(500000, 500000), nnz=12500000, layout=torch.sparse_csr)
tensor([0.2844, 0.4487, 0.9137, ..., 0.5004, 0.3000, 0.1233])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([500000, 500000])
Rows: 500000
Size: 250000000000
NNZ: 12500000
Density: 5e-05
Time: 4.620434761047363 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '2272', '-ss', '500000', '-sd', '5e-05', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [500000, 500000], "MATRIX_ROWS": 500000, "MATRIX_SIZE": 250000000000, "MATRIX_NNZ": 12500000, "MATRIX_DENSITY": 5e-05, "TIME_S": 9.761992931365967}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 25, 50, ..., 12499939,
12499968, 12500000]),
col_indices=tensor([ 35309, 102593, 109410, ..., 438712, 452154,
489935]),
values=tensor([0.4991, 0.7582, 0.4985, ..., 0.8355, 0.6986, 0.3665]),
size=(500000, 500000), nnz=12500000, layout=torch.sparse_csr)
tensor([0.1755, 0.5499, 0.0031, ..., 0.2944, 0.6143, 0.3232])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([500000, 500000])
Rows: 500000
Size: 250000000000
NNZ: 12500000
Density: 5e-05
Time: 9.761992931365967 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '2443', '-ss', '500000', '-sd', '5e-05', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [500000, 500000], "MATRIX_ROWS": 500000, "MATRIX_SIZE": 250000000000, "MATRIX_NNZ": 12500000, "MATRIX_DENSITY": 5e-05, "TIME_S": 11.091211557388306}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 29, 54, ..., 12499940,
12499966, 12500000]),
col_indices=tensor([ 15104, 53699, 66016, ..., 451008, 478949,
498027]),
values=tensor([0.3834, 0.0166, 0.8269, ..., 0.7083, 0.6634, 0.5753]),
size=(500000, 500000), nnz=12500000, layout=torch.sparse_csr)
tensor([0.3028, 0.2567, 0.4384, ..., 0.4923, 0.2329, 0.9462])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([500000, 500000])
Rows: 500000
Size: 250000000000
NNZ: 12500000
Density: 5e-05
Time: 11.091211557388306 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 29, 54, ..., 12499940,
12499966, 12500000]),
col_indices=tensor([ 15104, 53699, 66016, ..., 451008, 478949,
498027]),
values=tensor([0.3834, 0.0166, 0.8269, ..., 0.7083, 0.6634, 0.5753]),
size=(500000, 500000), nnz=12500000, layout=torch.sparse_csr)
tensor([0.3028, 0.2567, 0.4384, ..., 0.4923, 0.2329, 0.9462])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([500000, 500000])
Rows: 500000
Size: 250000000000
NNZ: 12500000
Density: 5e-05
Time: 11.091211557388306 seconds
[41.47, 41.03, 39.87, 40.83, 39.9, 40.09, 40.23, 40.2, 39.74, 39.65]
[125.74]
16.646742820739746
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 2443, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [500000, 500000], 'MATRIX_ROWS': 500000, 'MATRIX_SIZE': 250000000000, 'MATRIX_NNZ': 12500000, 'MATRIX_DENSITY': 5e-05, 'TIME_S': 11.091211557388306, 'TIME_S_1KI': 4.5399965441622205, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 2093.1614422798157, 'W': 125.74}
[41.47, 41.03, 39.87, 40.83, 39.9, 40.09, 40.23, 40.2, 39.74, 39.65, 40.36, 39.88, 39.75, 39.86, 39.72, 40.13, 40.1, 39.56, 45.29, 40.14]
726.99
36.3495
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 2443, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [500000, 500000], 'MATRIX_ROWS': 500000, 'MATRIX_SIZE': 250000000000, 'MATRIX_NNZ': 12500000, 'MATRIX_DENSITY': 5e-05, 'TIME_S': 11.091211557388306, 'TIME_S_1KI': 4.5399965441622205, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 2093.1614422798157, 'W': 125.74, 'J_1KI': 856.7996079737272, 'W_1KI': 51.469504707327054, 'W_D': 89.3905, 'J_D': 1488.0606641173363, 'W_D_1KI': 36.59046254604994, 'J_D_1KI': 14.977676031948402}

1
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_50000_0.0001.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Epyc 7313P", "CORES": 16, "ITERATIONS": 91834, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [50000, 50000], "MATRIX_ROWS": 50000, "MATRIX_SIZE": 2500000000, "MATRIX_NNZ": 250000, "MATRIX_DENSITY": 0.0001, "TIME_S": 10.82576298713684, "TIME_S_1KI": 0.11788404062914433, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 1647.9860616016388, "W": 116.97, "J_1KI": 17.945271485524305, "W_1KI": 1.273711261624235, "W_D": 80.83175, "J_D": 1138.8355760867596, "W_D_1KI": 0.8801941546703835, "J_D_1KI": 0.009584621759592129}

125
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_50000_0.0001.output Normal file
View File

@ -0,0 +1,125 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '1000', '-ss', '50000', '-sd', '0.0001', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [50000, 50000], "MATRIX_ROWS": 50000, "MATRIX_SIZE": 2500000000, "MATRIX_NNZ": 250000, "MATRIX_DENSITY": 0.0001, "TIME_S": 0.14647722244262695}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 6, 8, ..., 249988, 249995,
250000]),
col_indices=tensor([ 544, 6056, 19594, ..., 16208, 31107, 37035]),
values=tensor([0.8576, 0.5005, 0.2810, ..., 0.0063, 0.7171, 0.8258]),
size=(50000, 50000), nnz=250000, layout=torch.sparse_csr)
tensor([0.4318, 0.7107, 0.2576, ..., 0.8496, 0.3705, 0.3608])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([50000, 50000])
Rows: 50000
Size: 2500000000
NNZ: 250000
Density: 0.0001
Time: 0.14647722244262695 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '71683', '-ss', '50000', '-sd', '0.0001', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [50000, 50000], "MATRIX_ROWS": 50000, "MATRIX_SIZE": 2500000000, "MATRIX_NNZ": 250000, "MATRIX_DENSITY": 0.0001, "TIME_S": 9.233005046844482}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 7, 10, ..., 249988, 249994,
250000]),
col_indices=tensor([ 4979, 12449, 23825, ..., 32585, 40358, 48594]),
values=tensor([0.7825, 0.8569, 0.5029, ..., 0.3250, 0.4106, 0.3303]),
size=(50000, 50000), nnz=250000, layout=torch.sparse_csr)
tensor([0.8033, 0.4755, 0.5204, ..., 0.8611, 0.9528, 0.0172])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([50000, 50000])
Rows: 50000
Size: 2500000000
NNZ: 250000
Density: 0.0001
Time: 9.233005046844482 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '81519', '-ss', '50000', '-sd', '0.0001', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [50000, 50000], "MATRIX_ROWS": 50000, "MATRIX_SIZE": 2500000000, "MATRIX_NNZ": 250000, "MATRIX_DENSITY": 0.0001, "TIME_S": 9.805182695388794}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 6, 11, ..., 249983, 249992,
250000]),
col_indices=tensor([ 7422, 17911, 31055, ..., 30707, 32021, 38558]),
values=tensor([0.7718, 0.8036, 0.8293, ..., 0.2159, 0.0251, 0.0647]),
size=(50000, 50000), nnz=250000, layout=torch.sparse_csr)
tensor([0.3183, 0.3041, 0.1046, ..., 0.2603, 0.8118, 0.2097])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([50000, 50000])
Rows: 50000
Size: 2500000000
NNZ: 250000
Density: 0.0001
Time: 9.805182695388794 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '87295', '-ss', '50000', '-sd', '0.0001', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [50000, 50000], "MATRIX_ROWS": 50000, "MATRIX_SIZE": 2500000000, "MATRIX_NNZ": 250000, "MATRIX_DENSITY": 0.0001, "TIME_S": 9.980920553207397}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 3, 5, ..., 249989, 249993,
250000]),
col_indices=tensor([19530, 21432, 40127, ..., 33319, 45642, 48654]),
values=tensor([0.8438, 0.0330, 0.2387, ..., 0.6115, 0.5796, 0.5067]),
size=(50000, 50000), nnz=250000, layout=torch.sparse_csr)
tensor([0.1992, 0.5617, 0.3460, ..., 0.4818, 0.9372, 0.6597])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([50000, 50000])
Rows: 50000
Size: 2500000000
NNZ: 250000
Density: 0.0001
Time: 9.980920553207397 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '91834', '-ss', '50000', '-sd', '0.0001', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [50000, 50000], "MATRIX_ROWS": 50000, "MATRIX_SIZE": 2500000000, "MATRIX_NNZ": 250000, "MATRIX_DENSITY": 0.0001, "TIME_S": 10.82576298713684}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 7, 12, ..., 249987, 249995,
250000]),
col_indices=tensor([ 2714, 5631, 18387, ..., 39061, 48792, 49070]),
values=tensor([0.1970, 0.9435, 0.9859, ..., 0.7944, 0.6863, 0.0587]),
size=(50000, 50000), nnz=250000, layout=torch.sparse_csr)
tensor([0.5128, 0.8861, 0.8900, ..., 0.3721, 0.4809, 0.7353])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([50000, 50000])
Rows: 50000
Size: 2500000000
NNZ: 250000
Density: 0.0001
Time: 10.82576298713684 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 7, 12, ..., 249987, 249995,
250000]),
col_indices=tensor([ 2714, 5631, 18387, ..., 39061, 48792, 49070]),
values=tensor([0.1970, 0.9435, 0.9859, ..., 0.7944, 0.6863, 0.0587]),
size=(50000, 50000), nnz=250000, layout=torch.sparse_csr)
tensor([0.5128, 0.8861, 0.8900, ..., 0.3721, 0.4809, 0.7353])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([50000, 50000])
Rows: 50000
Size: 2500000000
NNZ: 250000
Density: 0.0001
Time: 10.82576298713684 seconds
[40.37, 39.3, 39.3, 39.19, 39.7, 39.15, 40.14, 44.33, 39.43, 39.81]
[116.97]
14.088963508605957
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 91834, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [50000, 50000], 'MATRIX_ROWS': 50000, 'MATRIX_SIZE': 2500000000, 'MATRIX_NNZ': 250000, 'MATRIX_DENSITY': 0.0001, 'TIME_S': 10.82576298713684, 'TIME_S_1KI': 0.11788404062914433, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 1647.9860616016388, 'W': 116.97}
[40.37, 39.3, 39.3, 39.19, 39.7, 39.15, 40.14, 44.33, 39.43, 39.81, 40.26, 39.09, 41.97, 44.11, 39.87, 39.01, 40.55, 38.99, 38.97, 38.89]
722.7650000000001
36.138250000000006
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 91834, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [50000, 50000], 'MATRIX_ROWS': 50000, 'MATRIX_SIZE': 2500000000, 'MATRIX_NNZ': 250000, 'MATRIX_DENSITY': 0.0001, 'TIME_S': 10.82576298713684, 'TIME_S_1KI': 0.11788404062914433, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 1647.9860616016388, 'W': 116.97, 'J_1KI': 17.945271485524305, 'W_1KI': 1.273711261624235, 'W_D': 80.83175, 'J_D': 1138.8355760867596, 'W_D_1KI': 0.8801941546703835, 'J_D_1KI': 0.009584621759592129}

1
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_50000_0.001.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Epyc 7313P", "CORES": 16, "ITERATIONS": 46775, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [50000, 50000], "MATRIX_ROWS": 50000, "MATRIX_SIZE": 2500000000, "MATRIX_NNZ": 2500000, "MATRIX_DENSITY": 0.001, "TIME_S": 10.762548208236694, "TIME_S_1KI": 0.2300918911434889, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 2033.0924378275872, "W": 149.27, "J_1KI": 43.46536478519695, "W_1KI": 3.1912346338856232, "W_D": 113.87475, "J_D": 1551.0008245763183, "W_D_1KI": 2.434521646178514, "J_D_1KI": 0.052047496444222636}

85
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_50000_0.001.output Normal file
View File

@ -0,0 +1,85 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '1000', '-ss', '50000', '-sd', '0.001', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [50000, 50000], "MATRIX_ROWS": 50000, "MATRIX_SIZE": 2500000000, "MATRIX_NNZ": 2500000, "MATRIX_DENSITY": 0.001, "TIME_S": 0.29659008979797363}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 46, 83, ..., 2499888,
2499946, 2500000]),
col_indices=tensor([ 2168, 2264, 3614, ..., 46868, 47216, 48811]),
values=tensor([0.2788, 0.0512, 0.3475, ..., 0.9281, 0.1898, 0.0144]),
size=(50000, 50000), nnz=2500000, layout=torch.sparse_csr)
tensor([0.5080, 0.1629, 0.0847, ..., 0.6599, 0.4582, 0.2341])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([50000, 50000])
Rows: 50000
Size: 2500000000
NNZ: 2500000
Density: 0.001
Time: 0.29659008979797363 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '35402', '-ss', '50000', '-sd', '0.001', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [50000, 50000], "MATRIX_ROWS": 50000, "MATRIX_SIZE": 2500000000, "MATRIX_NNZ": 2500000, "MATRIX_DENSITY": 0.001, "TIME_S": 7.946921348571777}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 54, 117, ..., 2499905,
2499953, 2500000]),
col_indices=tensor([ 1300, 1442, 2491, ..., 47415, 49147, 49910]),
values=tensor([0.1149, 0.9707, 0.0968, ..., 0.7933, 0.6392, 0.9343]),
size=(50000, 50000), nnz=2500000, layout=torch.sparse_csr)
tensor([0.2903, 0.7408, 0.0968, ..., 0.3344, 0.5691, 0.3821])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([50000, 50000])
Rows: 50000
Size: 2500000000
NNZ: 2500000
Density: 0.001
Time: 7.946921348571777 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '46775', '-ss', '50000', '-sd', '0.001', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [50000, 50000], "MATRIX_ROWS": 50000, "MATRIX_SIZE": 2500000000, "MATRIX_NNZ": 2500000, "MATRIX_DENSITY": 0.001, "TIME_S": 10.762548208236694}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 65, 117, ..., 2499903,
2499954, 2500000]),
col_indices=tensor([ 2232, 2981, 3015, ..., 49447, 49836, 49877]),
values=tensor([0.3281, 0.9452, 0.1004, ..., 0.4282, 0.2346, 0.1167]),
size=(50000, 50000), nnz=2500000, layout=torch.sparse_csr)
tensor([0.5238, 0.6081, 0.9163, ..., 0.2866, 0.2457, 0.9117])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([50000, 50000])
Rows: 50000
Size: 2500000000
NNZ: 2500000
Density: 0.001
Time: 10.762548208236694 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 65, 117, ..., 2499903,
2499954, 2500000]),
col_indices=tensor([ 2232, 2981, 3015, ..., 49447, 49836, 49877]),
values=tensor([0.3281, 0.9452, 0.1004, ..., 0.4282, 0.2346, 0.1167]),
size=(50000, 50000), nnz=2500000, layout=torch.sparse_csr)
tensor([0.5238, 0.6081, 0.9163, ..., 0.2866, 0.2457, 0.9117])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([50000, 50000])
Rows: 50000
Size: 2500000000
NNZ: 2500000
Density: 0.001
Time: 10.762548208236694 seconds
[41.04, 39.15, 39.26, 39.11, 39.17, 39.29, 39.32, 39.24, 39.56, 39.01]
[149.27]
13.620234727859497
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 46775, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [50000, 50000], 'MATRIX_ROWS': 50000, 'MATRIX_SIZE': 2500000000, 'MATRIX_NNZ': 2500000, 'MATRIX_DENSITY': 0.001, 'TIME_S': 10.762548208236694, 'TIME_S_1KI': 0.2300918911434889, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 2033.0924378275872, 'W': 149.27}
[41.04, 39.15, 39.26, 39.11, 39.17, 39.29, 39.32, 39.24, 39.56, 39.01, 39.97, 39.18, 39.31, 39.08, 39.46, 39.32, 39.13, 39.45, 39.15, 39.43]
707.905
35.39525
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 46775, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [50000, 50000], 'MATRIX_ROWS': 50000, 'MATRIX_SIZE': 2500000000, 'MATRIX_NNZ': 2500000, 'MATRIX_DENSITY': 0.001, 'TIME_S': 10.762548208236694, 'TIME_S_1KI': 0.2300918911434889, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 2033.0924378275872, 'W': 149.27, 'J_1KI': 43.46536478519695, 'W_1KI': 3.1912346338856232, 'W_D': 113.87475, 'J_D': 1551.0008245763183, 'W_D_1KI': 2.434521646178514, 'J_D_1KI': 0.052047496444222636}

1
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_50000_0.01.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Epyc 7313P", "CORES": 16, "ITERATIONS": 1728, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [50000, 50000], "MATRIX_ROWS": 50000, "MATRIX_SIZE": 2500000000, "MATRIX_NNZ": 25000000, "MATRIX_DENSITY": 0.01, "TIME_S": 10.847445249557495, "TIME_S_1KI": 6.277456741642069, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 2262.675802116394, "W": 116.47, "J_1KI": 1309.418866965506, "W_1KI": 67.40162037037037, "W_D": 80.83224999999999, "J_D": 1570.3372207918164, "W_D_1KI": 46.7779224537037, "J_D_1KI": 27.070556975522976}

65
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_50000_0.01.output Normal file
View File

@ -0,0 +1,65 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '1000', '-ss', '50000', '-sd', '0.01', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [50000, 50000], "MATRIX_ROWS": 50000, "MATRIX_SIZE": 2500000000, "MATRIX_NNZ": 25000000, "MATRIX_DENSITY": 0.01, "TIME_S": 6.073575019836426}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 511, 999, ..., 24998996,
24999515, 25000000]),
col_indices=tensor([ 50, 140, 163, ..., 49849, 49891, 49909]),
values=tensor([0.6896, 0.4241, 0.6835, ..., 0.3809, 0.0330, 0.1679]),
size=(50000, 50000), nnz=25000000, layout=torch.sparse_csr)
tensor([0.8743, 0.1159, 0.4633, ..., 0.1043, 0.2471, 0.3798])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([50000, 50000])
Rows: 50000
Size: 2500000000
NNZ: 25000000
Density: 0.01
Time: 6.073575019836426 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '1728', '-ss', '50000', '-sd', '0.01', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [50000, 50000], "MATRIX_ROWS": 50000, "MATRIX_SIZE": 2500000000, "MATRIX_NNZ": 25000000, "MATRIX_DENSITY": 0.01, "TIME_S": 10.847445249557495}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 553, 1047, ..., 24998955,
24999507, 25000000]),
col_indices=tensor([ 47, 133, 262, ..., 49731, 49773, 49776]),
values=tensor([0.8665, 0.6889, 0.7366, ..., 0.8541, 0.3572, 0.3739]),
size=(50000, 50000), nnz=25000000, layout=torch.sparse_csr)
tensor([0.0392, 0.1826, 0.6698, ..., 0.4937, 0.5808, 0.8286])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([50000, 50000])
Rows: 50000
Size: 2500000000
NNZ: 25000000
Density: 0.01
Time: 10.847445249557495 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 553, 1047, ..., 24998955,
24999507, 25000000]),
col_indices=tensor([ 47, 133, 262, ..., 49731, 49773, 49776]),
values=tensor([0.8665, 0.6889, 0.7366, ..., 0.8541, 0.3572, 0.3739]),
size=(50000, 50000), nnz=25000000, layout=torch.sparse_csr)
tensor([0.0392, 0.1826, 0.6698, ..., 0.4937, 0.5808, 0.8286])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([50000, 50000])
Rows: 50000
Size: 2500000000
NNZ: 25000000
Density: 0.01
Time: 10.847445249557495 seconds
[40.17, 39.47, 39.62, 39.58, 39.57, 39.35, 40.27, 39.27, 39.48, 39.51]
[116.47]
19.427112579345703
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 1728, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [50000, 50000], 'MATRIX_ROWS': 50000, 'MATRIX_SIZE': 2500000000, 'MATRIX_NNZ': 25000000, 'MATRIX_DENSITY': 0.01, 'TIME_S': 10.847445249557495, 'TIME_S_1KI': 6.277456741642069, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 2262.675802116394, 'W': 116.47}
[40.17, 39.47, 39.62, 39.58, 39.57, 39.35, 40.27, 39.27, 39.48, 39.51, 40.76, 39.62, 39.66, 39.43, 39.52, 39.33, 39.97, 39.4, 39.29, 39.41]
712.7550000000001
35.637750000000004
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 1728, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [50000, 50000], 'MATRIX_ROWS': 50000, 'MATRIX_SIZE': 2500000000, 'MATRIX_NNZ': 25000000, 'MATRIX_DENSITY': 0.01, 'TIME_S': 10.847445249557495, 'TIME_S_1KI': 6.277456741642069, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 2262.675802116394, 'W': 116.47, 'J_1KI': 1309.418866965506, 'W_1KI': 67.40162037037037, 'W_D': 80.83224999999999, 'J_D': 1570.3372207918164, 'W_D_1KI': 46.7779224537037, 'J_D_1KI': 27.070556975522976}

1
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_50000_1e-05.json Normal file
View File

@ -0,0 +1 @@
{"CPU": "Epyc 7313P", "CORES": 16, "ITERATIONS": 128043, "MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [50000, 50000], "MATRIX_ROWS": 50000, "MATRIX_SIZE": 2500000000, "MATRIX_NNZ": 25000, "MATRIX_DENSITY": 1e-05, "TIME_S": 10.502545356750488, "TIME_S_1KI": 0.08202358080293722, "BASELINE_TIME_S": 10, "BASELINE_DELAY_S": 10, "J": 1345.7720102190972, "W": 103.43, "J_1KI": 10.510313021556017, "W_1KI": 0.8077755129136307, "W_D": 68.14325000000001, "J_D": 886.6409990850092, "W_D_1KI": 0.532190357926634, "J_D_1KI": 0.004156340900530557}

81
pytorch/output_synthetic_16core_old/epyc_7313p_16_csr_10_10_10_synthetic_50000_1e-05.output Normal file
View File

@ -0,0 +1,81 @@
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '1000', '-ss', '50000', '-sd', '1e-05', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [50000, 50000], "MATRIX_ROWS": 50000, "MATRIX_SIZE": 2500000000, "MATRIX_NNZ": 25000, "MATRIX_DENSITY": 1e-05, "TIME_S": 0.1170039176940918}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 0, 2, ..., 25000, 25000, 25000]),
col_indices=tensor([20669, 48572, 15521, ..., 4942, 37440, 49163]),
values=tensor([0.4805, 0.0794, 0.3246, ..., 0.3038, 0.8605, 0.6038]),
size=(50000, 50000), nnz=25000, layout=torch.sparse_csr)
tensor([0.4235, 0.9189, 0.0697, ..., 0.8234, 0.9093, 0.0251])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([50000, 50000])
Rows: 50000
Size: 2500000000
NNZ: 25000
Density: 1e-05
Time: 0.1170039176940918 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '89740', '-ss', '50000', '-sd', '1e-05', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [50000, 50000], "MATRIX_ROWS": 50000, "MATRIX_SIZE": 2500000000, "MATRIX_NNZ": 25000, "MATRIX_DENSITY": 1e-05, "TIME_S": 7.3589677810668945}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 0, 0, ..., 24998, 24999, 25000]),
col_indices=tensor([42797, 39277, 20964, ..., 31232, 43143, 42518]),
values=tensor([0.7162, 0.4091, 0.9127, ..., 0.7828, 0.7816, 0.8353]),
size=(50000, 50000), nnz=25000, layout=torch.sparse_csr)
tensor([0.2017, 0.4349, 0.5577, ..., 0.2868, 0.8229, 0.7966])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([50000, 50000])
Rows: 50000
Size: 2500000000
NNZ: 25000
Density: 1e-05
Time: 7.3589677810668945 seconds
['apptainer', 'run', '--env', 'OMP_PROC_BIND=true', '--env', 'OMP_PLACES={0:16}', 'pytorch-epyc_7313p.sif', 'python3', 'spmv.py', 'synthetic', 'csr', '128043', '-ss', '50000', '-sd', '1e-05', '-c', '16']
{"MATRIX_TYPE": "synthetic", "MATRIX_FORMAT": "csr", "MATRIX_SHAPE": [50000, 50000], "MATRIX_ROWS": 50000, "MATRIX_SIZE": 2500000000, "MATRIX_NNZ": 25000, "MATRIX_DENSITY": 1e-05, "TIME_S": 10.502545356750488}
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 0, 0, ..., 24999, 24999, 25000]),
col_indices=tensor([18076, 25567, 40242, ..., 19386, 42443, 43843]),
values=tensor([0.1613, 0.4932, 0.9378, ..., 0.7394, 0.5576, 0.1832]),
size=(50000, 50000), nnz=25000, layout=torch.sparse_csr)
tensor([0.1994, 0.9899, 0.9038, ..., 0.7869, 0.4416, 0.9952])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([50000, 50000])
Rows: 50000
Size: 2500000000
NNZ: 25000
Density: 1e-05
Time: 10.502545356750488 seconds
/nfshomes/vut/ampere_research/pytorch/spmv.py:75: UserWarning: Sparse CSR tensor support is in beta state. If you miss a functionality in the sparse tensor support, please submit a feature request to https://github.com/pytorch/pytorch/issues. (Triggered internally at ../aten/src/ATen/SparseCsrTensorImpl.cpp:53.)
matrix = matrix.to_sparse_csr().type(torch.float32)
tensor(crow_indices=tensor([ 0, 0, 0, ..., 24999, 24999, 25000]),
col_indices=tensor([18076, 25567, 40242, ..., 19386, 42443, 43843]),
values=tensor([0.1613, 0.4932, 0.9378, ..., 0.7394, 0.5576, 0.1832]),
size=(50000, 50000), nnz=25000, layout=torch.sparse_csr)
tensor([0.1994, 0.9899, 0.9038, ..., 0.7869, 0.4416, 0.9952])
Matrix Type: synthetic
Matrix Format: csr
Shape: torch.Size([50000, 50000])
Rows: 50000
Size: 2500000000
NNZ: 25000
Density: 1e-05
Time: 10.502545356750488 seconds
[40.3, 39.43, 39.29, 39.36, 38.95, 39.04, 39.78, 38.84, 39.12, 39.2]
[103.43]
13.011428117752075
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 128043, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [50000, 50000], 'MATRIX_ROWS': 50000, 'MATRIX_SIZE': 2500000000, 'MATRIX_NNZ': 25000, 'MATRIX_DENSITY': 1e-05, 'TIME_S': 10.502545356750488, 'TIME_S_1KI': 0.08202358080293722, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 1345.7720102190972, 'W': 103.43}
[40.3, 39.43, 39.29, 39.36, 38.95, 39.04, 39.78, 38.84, 39.12, 39.2, 40.2, 39.28, 39.13, 39.22, 38.89, 38.97, 38.85, 39.3, 39.03, 38.81]
705.7349999999999
35.28675
{'CPU': 'Epyc 7313P', 'CORES': 16, 'ITERATIONS': 128043, 'MATRIX_TYPE': 'synthetic', 'MATRIX_FORMAT': 'csr', 'MATRIX_SHAPE': [50000, 50000], 'MATRIX_ROWS': 50000, 'MATRIX_SIZE': 2500000000, 'MATRIX_NNZ': 25000, 'MATRIX_DENSITY': 1e-05, 'TIME_S': 10.502545356750488, 'TIME_S_1KI': 0.08202358080293722, 'BASELINE_TIME_S': 10, 'BASELINE_DELAY_S': 10, 'J': 1345.7720102190972, 'W': 103.43, 'J_1KI': 10.510313021556017, 'W_1KI': 0.8077755129136307, 'W_D': 68.14325000000001, 'J_D': 886.6409990850092, 'W_D_1KI': 0.532190357926634, 'J_D_1KI': 0.004156340900530557}

Some files were not shown because too many files have changed in this diff Show More