CodeXL

// Celem tego programu jest prezentacja pomiaru i analizy
//efektywnosci programu za pomocš  CodeAnalyst(tm).
// Implementacja mnożenia macierzy jest realizowana za pomoca typowego
// algorytmu podręcznikowego.
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <time.h>
#include <windows.h>
#include "omp.h"
#include <fstream>
#include <iostream>
#include <string>
#include <vector>
#include <sstream>
#include <streambuf>

#define USE_MULTIPLE_THREADS true
#define MAXTHREADS 128
int NumThreads;
double start;
using namespace std;
static const int ROWS = 5;     // liczba wierszy macierzy
static const int COLUMNS = 5;  // lizba kolumn macierzy

float matrix_a[ROWS][COLUMNS];    // lewy operand
float matrix_b[ROWS][COLUMNS];    // prawy operand
float matrix_r[ROWS][COLUMNS];    // wynik
float matrix_good[ROWS][COLUMNS];    // 100% poprawny wynik

FILE *result_file;

void initialize_matrices()
{
    // zdefiniowanie zawarosci poczatkowej macierzy
    //#pragma omp parallel for
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLUMNS; j++) {
            matrix_a[i][j] = (float)rand() / RAND_MAX;
            matrix_b[i][j] = (float)rand() / RAND_MAX;
            matrix_r[i][j] = 0.0;
        }
    }
}
void show(){
    for (int k = 0; k < COLUMNS; k++)
        for (int i = 0; i < ROWS; i++)
            cout << matrix_a[i][k] << endl;
}

void splitString(string s, float **matrix, int column_count){

    istringstream iss(s);
    vector<string> tokens;
    copy(istream_iterator<string>(iss),
        istream_iterator<string>(),
        back_inserter(tokens));
    int x, y;
    for (int i = 0; i < tokens.size(); i++)
    {
        y = i % column_count;
        x = (int)(i / column_count);

        matrix[x][y] = stof(tokens[i].c_str());
        //cout << matrix[i] << endl;
    }
}

void load(){

    ifstream t("macierz.txt");
    string data((std::istreambuf_iterator<char>(t)),
        std::istreambuf_iterator<char>());
    t.close();

    ifstream plik;
    plik.open("macierz.txt");
    if (plik.good() == true)
    {


        int flag = 0;
        int a = 0;
        int sep_pos = -1;
        char ch;
        cout << "Uzyskano dostep do pliku!" << endl;
        while (!plik.eof()){
            plik.get(ch);
            if ((ch == '#') && (!flag)){
                sep_pos = a;
                flag = 1;
                //cout << "chuj" << a;
                break;
            }
            a++;
        }

        if (flag){
            //cout << sep_pos;

            cout << data.substr(0, sep_pos);
            cout << endl << data.substr(sep_pos + 1);

            float **mat = new float*[99];
            float **mat2 = new float*[99];
            for (int i = 0; i < 99; i++) {
                mat[i] = new float[99];
                mat2[i] = new float[99];
            }

            splitString(data.substr(0, sep_pos-1), mat, 5);
            splitString(data.substr(sep_pos+1), mat2,5);

        }

    }
    else cout << "Dostep do pliku zostal zabroniony!" << endl;

    plik.close();
}






void check(){
    for (int j = 0; j < COLUMNS; j++)
        for (int k = 0; k < COLUMNS; k++)
            for (int i = 0; i < ROWS; i++)
                matrix_r[i][j] += matrix_a[i][k] * matrix_b[k][j];

    memcpy(&matrix_good, &matrix_r, sizeof(matrix_r));
}

void initialize_matricesZ()
{
    // zdefiniowanie zawarosci poczatkowej macierzy
#pragma omp parallel for
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLUMNS; j++) {
            matrix_r[i][j] = 0.0;
        }
    }
}
void print_result()
{
    // wydruk wyniku
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLUMNS; j++) {
            fprintf(result_file, "%6.4f ", matrix_r[i][j]);
        }
        fprintf(result_file, "\n");
    }
}


void JKI1()
{
    // mnozenie macierzy
#pragma omp parallel for
    for (int j = 0; j < COLUMNS; j++)
        for (int k = 0; k < COLUMNS; k++)
            for (int i = 0; i < ROWS; i++)
                matrix_r[i][j] += matrix_a[i][k] * matrix_b[k][j];
    memcmp(&matrix_r, &matrix_good, sizeof(matrix_good));
}

void JKI2()
{
    // mnozenie macierzy
    for (int j = 0; j < COLUMNS; j++)
#pragma omp parallel for
        for (int k = 0; k < COLUMNS; k++)
            for (int i = 0; i < ROWS; i++)
                matrix_r[i][j] += matrix_a[i][k] * matrix_b[k][j];
    memcmp(&matrix_r, &matrix_good, sizeof(matrix_good));
}

void JKI3()
{
    // mnozenie macierzy

    for (int j = 0; j < COLUMNS; j++)
        for (int k = 0; k < COLUMNS; k++)
#pragma omp parallel for
            for (int i = 0; i < ROWS; i++)
                matrix_r[i][j] += matrix_a[i][k] * matrix_b[k][j];
    memcmp(&matrix_r, &matrix_good, sizeof(matrix_good));
}

void print_elapsed_time()
{
    double elapsed;
    double resolution;

    // wyznaczenie i zapisanie czasu przetwarzania
    elapsed = (double)clock() / CLK_TCK;
    resolution = 1.0 / CLK_TCK;
    printf("Czas: %8.4f sec \n",
        elapsed - start);

    fprintf(result_file,
        "Czas wykonania programu: %8.4f sec (%6.4f sec rozdzielczosc pomiaru)\n",
        elapsed - start, resolution);
}

int main(int argc, char* argv[])
{
/*  //   start = (double) clock() / CLK_TCK ;
    if ((result_file = fopen("classic.txt", "a")) == NULL) {
        fprintf(stderr, "nie mozna otworzyc pliku wyniku \n");
        perror("classic");
        return(EXIT_FAILURE);
    }


    //Determine the number of threads to use
    if (USE_MULTIPLE_THREADS) {
        SYSTEM_INFO SysInfo;
        GetSystemInfo(&SysInfo);
        NumThreads = SysInfo.dwNumberOfProcessors;
        if (NumThreads > MAXTHREADS)
            NumThreads = MAXTHREADS;
    }
    else
        NumThreads = 1;
    fprintf(result_file, "Klasyczny algorytm mnozenia macierzy, liczba watkow %d \n", NumThreads);
    printf("liczba watkow  = %d\n\n", NumThreads);

    initialize_matrices();
    start = (double)clock() / CLK_TCK;
    JKI1();
    printf("JKI1 ");
    print_elapsed_time();
    initialize_matricesZ();
    start = (double)clock() / CLK_TCK;
    JKI2();
    printf("JKI2 ");
    print_elapsed_time();
    initialize_matricesZ();
    start = (double)clock() / CLK_TCK;
    JKI3();
    printf("JKI3 ");
    print_elapsed_time();

    fclose(result_file);
*/
    load();

    system("PAUSE");
    return(0);

}