LINUX.ORG.RU

Сообщения Gold_Oldmen

 

Реализовать последовательно-параллельный запуск потоков

Тут есть граф запуска потоков, в нем надо выделить три группы потоков: не синхронизированную, синхронизирована мьютексом и синхронизированную семафорами. http://s019.radikal.ru/i633/1706/5c/dfc357ea6270.png Я уже дня три верчу и так, и этак. А чертовы потоки то отваливаются, то идут не в той последовательности. Помогите, пожалуйста. Может вы увидете, где я в глаза долблюсь.

#include <stdlib.h>
#include <unistd.h>
#include <iostream>
#include <pthread.h>
#include <semaphore.h>

void *thread_function_a(void *arg);
void *thread_function_c(void *arg);
void *thread_function_e(void *arg);
void *thread_function_b(void *arg);
void *thread_function_d(void *arg);
void *thread_function_f(void *arg);
void *thread_function_h(void *arg);
void *thread_function_g(void *arg);
void *thread_function_i(void *arg);
void *thread_function_k(void *arg);
void *thread_function_m(void *arg);
void *thread_function_n(void *arg);

pthread_mutex_t i_mutex;
pthread_mutex_t n_mutex;
pthread_mutex_t k_mutex;
pthread_mutex_t c_mutex;
pthread_mutex_t d_mutex;
pthread_mutex_t h_mutex;
pthread_mutex_t g_mutex;

sem_t semaphore;

pthread_t a_thread;
pthread_t b_thread;
pthread_t c_thread;
pthread_t d_thread;
pthread_t e_thread;
pthread_t f_thread;
pthread_t h_thread;
pthread_t g_thread;
pthread_t i_thread;
pthread_t k_thread;
pthread_t m_thread;
pthread_t n_thread;

int main(int argc, char * argv[])
{
pthread_mutex_lock(&c_mutex);
pthread_mutex_lock(&d_mutex);
pthread_mutex_lock(&h_mutex);
pthread_mutex_lock(&g_mutex);

sem_init(&semaphore, 0, 3);

pthread_create(&a_thread, NULL, thread_function_a, (void*)"a");
pthread_create(&b_thread, NULL, thread_function_b, (void*)"b");
pthread_create(&c_thread, NULL, thread_function_c, (void*)"c");
pthread_create(&d_thread, NULL, thread_function_d, (void*)"d");
pthread_create(&e_thread, NULL, thread_function_e, (void*)"e");
pthread_create(&f_thread, NULL, thread_function_f, (void*)"f");
pthread_create(&h_thread, NULL, thread_function_h, (void*)"h");
pthread_create(&g_thread, NULL, thread_function_g, (void*)"g");
pthread_create(&i_thread, NULL, thread_function_i, (void*)"i");
pthread_create(&k_thread, NULL, thread_function_k, (void*)"k");
pthread_create(&m_thread, NULL, thread_function_m, (void*)"m");
pthread_create(&n_thread, NULL, thread_function_n, (void*)"n");

pthread_join(e_thread,NULL);
pthread_join(d_thread,NULL);
pthread_join(f_thread,NULL);
pthread_join(g_thread,NULL);
pthread_join(h_thread,NULL);
pthread_join(i_thread,NULL);

pthread_mutex_destroy(&c_mutex);
pthread_mutex_destroy(&d_mutex);
pthread_mutex_destroy(&g_mutex);
pthread_mutex_destroy(&h_mutex);

std::cout <<"\n";
return 0;
}


void *thread_function_a(void *arg)
{
int x = 2;
for(int i = 0; i<x;i++){
std::cout <<(char*)arg;
usleep(10);
}
pthread_mutex_unlock(&c_mutex);
return NULL;
} 

void *thread_function_b(void *arg)
{
pthread_join(a_thread,NULL);
int x =3;
for(int i = 0; i<x;i++){
std::cout <<(char*)arg;
usleep(100);
}
pthread_mutex_unlock(&k_mutex);
return NULL;
}

void *thread_function_c(void *arg)
{
pthread_mutex_lock(&c_mutex); 
int x = 7;
for(int i = 0; i<x;i++){
std::cout <<(char*)arg;
usleep(100);
}
return NULL;
}

void *thread_function_e(void *arg)
{
pthread_join(b_thread,NULL);
int x =4;
for(int i = 0; i<x;i++){
std::cout <<(char*)arg;
usleep(100);
}
pthread_mutex_unlock(&k_mutex);
return NULL;
}

void *thread_function_d(void *arg)
{
pthread_mutex_lock(&d_mutex);
int x = 7;
for(int i = 0; i<x;i++){
std::cout <<(char*)arg;
usleep(100);
}
return NULL;
}

void *thread_function_f(void *arg)
{
pthread_join(b_thread,NULL);
int x =3;
for(int i = 0; i<x;i++){
std::cout <<(char*)arg;
usleep(100);
}
pthread_mutex_unlock(&h_mutex);
return NULL;
}


void *thread_function_k(void *arg)
{
pthread_mutex_lock(&k_mutex);
sem_wait(&semaphore);
int x = 5;
for(int i = 0; i<x;i++){
std::cout <<(char*)arg;
usleep(100);
}
sem_post(&semaphore);
pthread_mutex_unlock(&i_mutex);
return NULL;
}

void *thread_function_i(void *arg)
{
pthread_join(k_thread,NULL);
pthread_join(d_thread,NULL);
pthread_join(g_thread,NULL);
sem_wait(&semaphore);
int x = 4;
for(int i = 0; i<x;i++){
std::cout <<(char*)arg;
usleep(100);
}
sem_post(&semaphore);
return NULL;
}

void *thread_function_m(void *arg)
{
pthread_join(e_thread,NULL);
sem_wait(&semaphore);
int x = 6;
for(int i = 0; i<x;i++){
std::cout <<(char*)arg;
usleep(100);
}
sem_post(&semaphore);
pthread_mutex_unlock(&n_mutex);
return NULL;
}

void *thread_function_g(void *arg)
{
pthread_join(f_thread,NULL);
sem_wait(&semaphore);
int x = 4;
for(int i = 0; i<x;i++){
std::cout <<(char*)arg;
usleep(100);
}
sem_post(&semaphore);
return NULL;
}

void *thread_function_h(void *arg)
{
pthread_mutex_lock(&h_mutex);
sem_wait(&semaphore);
int x = 7;
for(int i = 0; i<x;i++){
std::cout <<(char*)arg;
usleep(100);
}
sem_post(&semaphore);
pthread_mutex_unlock(&n_mutex);
return NULL;
}


void *thread_function_n(void *arg)
{
pthread_join(i_thread,NULL);
pthread_join(m_thread,NULL);
pthread_join(h_thread,NULL);

int x = 2;
for(int i = 0; i<x;i++){
std::cout <<(char*)arg;
usleep(100);
}
return NULL;}

 ,

Gold_Oldmen
()
13 комментариев

Работа с Bison. Сложение вещественных чисел.

Доброго времени суток. Нужна помощь, ибо сам «в лыжи обутый». Необходимо запрограммировать вычисление синтезируемых атрибутов для программной реализации синтаксически управляемого сложения вещественных чисел.

Т.е. подаем строку 1.01+1.1 Должен быть ответ: 2.11.

Вот грамматика: 

S::=E
E::=T+T
T::=L.L
L::=B
L::=LB
B::=0|1|2|3|4|5|6|7|8|9

Понятия не имею, что можно сделать с третьим и пятым правилами. Сначала, довольный жизнью сганашил через математические выражения. Типа так: 

S: 	E{$$ = $1; cout << "Output string: " <<$$<<endl;};
E: 	T '+' T {$$=$1+$3;};	
T: 	L '.' L{$$=$1+0.1*$3/10;}; 
L: 	B{$$ = $1; cout<<$$<<endl;};
	|
	L B {$$=$1*10+$2;cout<<$$<<'\n';} ;
B: 	  '0' {$$ = 0;}
	| '1' {$$ = 1;}
	| '2' {$$ = 2;}
Но такой подход не подходит для чисел с разной разрядностью. Потом попробовал все сделать строками, а потом через atoi - тоже не сложилось.

В идеале, как сказал препод, надо бы сделать атрибуты массивами. А в конце запрограммировать сложение в столбик. Буду рад любым идеям. Заранее спасибо.

 ,

Gold_Oldmen
()
12 комментариев

RSS подписка на новые темы