Sparse matrix multiplication. single-thread

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <time.h>
#define ORD 200
#define SIZE (ORD*ORD/100)

typedef struct _matrix {
    int size;
    int ord;
    int val[ORD*ORD];
    int col[ORD*ORD];
    int row[ORD*ORD];
} matrix;

matrix A, B, C;

void swap (matrix *m, int i, int j)
{
    int temp = m->val[i];
    m->val[i] = m->val[j];
    m->val[j] = temp;

    temp = m->row[i];
    m->row[i] = m->row[j];
    m->row[j] = temp;

    temp = m->col[i];
    m->col[i] = m->col[j];
    m->col[j] = temp;
}

void fill_matrix (matrix* m)
{
    int i, j, gap;
    m->ord = ORD;
    m->size = SIZE;

    srand( time(NULL) );
    for (i = 0; i < SIZE; i++) {
        m->val[i] = rand() % 18 - 9;
        m->col[i] = rand() % ORD + 0;
        m->row[i] = rand() % ORD + 0;
    }

    for (gap = SIZE/2; gap > 0;gap /= 2)
        for (i = gap; i < SIZE; i++)
            for (j = i; j >= gap && ((m->row[j] < m->row[j-gap]) ||
                (m->row[j] == m->row[j-gap] && m->col[j] < m->col[j-gap])); j -= gap)
                swap (m, j, j - gap);

    printf("Matrix: ord:%dx%d size:%d (%d)\n", ORD, ORD, SIZE, ORD*ORD);
}

void multi (matrix* A, matrix* B, matrix* C)
{
    int i, j, k, l, p, q, m;
    int sum, curr_row_A, curr_row_B, curr_col_A, curr_col_B;
    int size = A->size, ord = A->ord;

    C->ord = ord;
    C->size = size;

    printf("calculating:");
    p = 0;
    q = 0;
    m = 0;
    for (i = 0; i < ord; i++) {
        //printf(" i=%d\n", i);
        for (j = 0; j < ord; j++) {
            //printf("  j=%d\n", j);
            sum = 0;
            for (k = p; k < size; k++) {
                curr_row_A = i;
                curr_row_B = j;
                curr_col_A = A->col[k];
                if (A->row[k] == i) {
                    for (l = q; l < size; l++) {
                        curr_col_B = B->col[l];
                        if (curr_col_A == curr_col_B && curr_row_B == B->row[l]) {
                            sum += A->val[k] * B->val[l];
                            break;
                        }
                    }
                }
            }
            if (0 != sum) {
                //printf("%d\n", sum);
                C->val[m] = sum;
                C->row[m] = i;
                C->col[m] = j;
                m++;
            }
        }
    }
    printf("done\n");
    printf("Result: ord:%dx%d size:%d (%d)\n", ord, ord, m, ord*ord);
}

int main()
{
    double single_thr_time, multi_thr_time, st0, st1, mt0, mt1;

    fill_matrix(&A);
    fill_matrix(&B);

    st0 = clock();
    multi(&A, &B, &C);
    st1 = clock();
    single_thr_time = st1 - st0;

    printf("\nsingle-thread time:%f\n", single_thr_time);

    return 0;
}