KernelImp/MultiThreadedSingleMatrixManip.cpp at master · lukes3315/KernelImp · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
#include <iostream>
#include <cstdlib>
#include <string.h>
#include <pthread.h>

#define Y 48
#define X 64

struct threadData
{
  int x, y;
  int lim_x, lim_y;
  char *** data;
  char c;
};

void * thread_method(void * data)
{
  threadData * _data = (threadData*)data;

  for (int y = _data->y; y < _data->lim_y ; ++y)
    {
      for (int x = _data->x ; x < _data->lim_x; ++x)
	{
	  char ** k = *_data->data;
	  k[y][x] = _data->c;
	}
    }
}

void displayData(char ** k)
{
  for (int i = 0 ; i < Y ; ++i)
    {
      std::cout << k[i] << std::endl;
    }
}

int main(void)
{
  char ** k = (char**)malloc(sizeof(char*) * Y);
  for (int i = 0 ; i < Y ; ++i)
    {
      k[i] = (char*)malloc(sizeof(char) * X);
      memset(k[i], '0', X);
    }
  pthread_t pthread[4];
  threadData data[4];

  for (int i = 0 ; i < 4; ++i)
    {
      switch (i)
	{
	case 0:
	  data[i].x = 0;
	  data[i].y = 0;
	  data[i].lim_x = X / 2;
	  data[i].lim_y = Y / 2;
	  data[i].c = '1';
	  data[i].data = &k;
	  if (!pthread_create(&pthread[i], NULL, thread_method, &data[i]))
	    {
	      std::cout << "good for thread #" << i << std::endl;
	    }
	  break;
	case 1:
	  data[i].x = X / 2;
	  data[i].y = 0;
	  data[i].lim_x = X;
	  data[i].lim_y = Y / 2;
	  data[i].c = '2';
	  data[i].data = &k;
	  if (!pthread_create(&pthread[i], NULL, thread_method, &data[i]))
	    {
	      std::cout << "good for thread #" << i << std::endl;
	    }
	  break;
	case 2:
	  data[i].x = 0;
	  data[i].y = Y / 2;
	  data[i].lim_x = X / 2;
	  data[i].lim_y = Y;
	  data[i].c = '3';
	  data[i].data = &k;
	  if (!pthread_create(&pthread[i], NULL, thread_method, &data[i]))
	    {
		std::cout << "good for thread #" << i << std::endl;
	    }
	  break;
	case 3:
	  data[i].x = X / 2;
	  data[i].y = Y / 2;
	  data[i].lim_x = X;
	  data[i].lim_y = Y;
	  data[i].c = '4';
	  data[i].data = &k;
	  if (!pthread_create(&pthread[i], NULL, thread_method, &data[i]))
	      {
		std::cout << "good for thread #" << i << std::endl;
	      }
	  break;
	}
    }

  if (!pthread_join(pthread[0], NULL)//(void**)&threaddataR)
      && !pthread_join(pthread[1], NULL)//(void**)&threaddataG)
      && !pthread_join(pthread[2], NULL)//(void**)&threaddataB))
      && !pthread_join(pthread[3], NULL))//(void**)&threaddataB))
    {
      displayData(k);
    }

  for (int i = 0 ; i < Y ; ++i)
    {
      free(k[i]);
    }
  free(k);


}