Премини към съдържанието

Препоръчан отговор


Здравейте имам задача "Да се състави програма на C която създава два процеса.Процесите комуникират през общата памет с размер едно цяло число.Първият процес генерира 400 произволни цели числа и ги записва в общата памет.Втория ги чете и ги записва във файл."

Записа във файл ми е ясно как ще стане, но ми трябва малко помощ относно това как трябва да се генерират и запишат числата в общата памет.Имам дадена следната функция за заемане на обща памет :

void * getmem (int i){
int shmid;

  shmid = shmget(70+i, SHMSIZE, IPC_CREAT|0666);
  return shmat(shmid,0,0);
}

А по този начин се извършва самото заемане :

int *r; 

r = (int *)getmem(4112); 

*r=0;

Проблема е там, че не знам как трябва да стане заемането на памет за 400 произволни цели числа.Ако може малко помощ ще съм благодарен :)

Сподели този отговор


Линк към този отговор
Сподели в други сайтове

току-що, notorious19 написа:

 

Здравейте имам задача "Да се състави програма на C която създава два процеса.Процесите комуникират през общата памет с размер едно цяло число.Първият процес генерира 400 произволни цели числа и ги записва в общата памет.Втория ги чете и ги записва във файл."

Проблема е там, че не знам как трябва да стане заемането на памет за 400 произволни цели числа.Ако може малко помощ ще съм благодарен :)

според мен си разбрал грешно условието. Мисля че целта е първия процес да записва числата едно по едно в общата памет и да сигнализира на втория след всяко. А вторият при сигнал го прочита и сигнализира обратно на първия, да пише следващото.

Сподели този отговор


Линк към този отговор
Сподели в други сайтове

Условието гласи точно това което съм написал, но дори и да е грешно кой е най-простия начин да се извърши това сигнализиране между процесите.Иначе възможно ли е задачата да се направи така че първо първият процес да записва числата в паметта, а след това втория оттам да ги записва във файл?

Редактирано от notorious19 (преглед на промените)

Сподели този отговор


Линк към този отговор
Сподели в други сайтове
преди 16 минути, notorious19 написа:

Условието гласи точно това което съм написал,

Условието гласи буквално че размерът на общата памет е за едно цяло число, не за 400.

Иначе може да се направи и по двата начина и вторият (ако цялата информацията ти е налична) очевидно е по-добър, защото ще стане с еднократна сигнализация, само че както казах условието е да имаш обща памет за 1 число и в нея не може едновременно да имаш 400 :D

Сигнализация най-лесно със семафор примерно. Иначе начини - бол. Идея си нямам какво сте учили.

Редактирано от flare (преглед на промените)

Сподели този отговор


Линк към този отговор
Сподели в други сайтове
struct myStruct {
	int num[400];
	int flag1;
	int flag2;
	int turn;
};

struct myStruct *cs;
cs = (struct myStruct *)getmem(4112);

srand ( time(NULL) );
	
for (i = 0; i < 400; i++) 
      cs->num[i] = rand()%100+1;

По този начин ако се направи първия процес да генерира случайни числа в обща памет, правилно ли ще бъде, понеже не мога да разбера принципа на работа на семафорите.Променливите flag1, flag2 и turn служат за синхронизация по алгоритъма на Декер.

Редактирано от notorious19 (преглед на промените)

Сподели този отговор


Линк към този отговор
Сподели в други сайтове
преди 4 часа, notorious19 написа:

По този начин ако се направи първия процес да генерира случайни числа в обща памет, правилно ли ще бъде, понеже не мога да разбера принципа на работа на семафорите.Променливите flag1, flag2 и turn служат за синхронизация по алгоритъма на Декер.

Алгоритъмът на Декер работи с т.нар busy wait, което може и да струва 1 стотинка, ако имаш голо C, ама като пишеш под каква да е нормална ОС, си е все едно да смяташ системи тригонометрични уравнения със детско сметало, вместо примерно wolframalpha... Отделно, на съвременен многоядрен процесор, нямаш никаква гаранция, че ще работи, щото достъпът дори до една променлива не е гарантирано атомичен.

Семафорите са абсолютно елементарни - представи си семафора, като променлива, за която имаш дефинирани операции само инициализиране, събиране с 1 и изваждане на 1, като изваждането не може да доведе до по-малка стойност от 0, а вместо това блокира докато някой друг не го увеличи с 1. Тоест този, който иска да използва ресурса чака(pend) на семафора (вади 1) - при което ако ресурса не е свободен (семафор == 0) блокира докато се освободи, изважда 1 правейки го пак 0, което пречи на всички други ползващи семафора да заемат ресурса  и след като си свърши работа го освобождава(post) (прибавя 1). Т.е. нещо такова

Нещо такова(ако sh_mem е указател към шерната памет цяло число, а sem е семафора.

Изпращащ

int i;
for (i = 0; i < 400; i++){
 	if(i) {
   		/* за всеки елемент след първия трябва да изчакаме получаващият да го освободи */
		sem_pend(&sem);
 	}
 	*sh_mem = rand()%100+1;
 	sem_post(&sem);
}

Получаващ.

int i;
for (i = 0; i < 400; i++){
 	sem_pend(&sem);
 	printf("%d\n", *shmem);
 	sem_post(&sem);
}

Естествено, в зависимост от имплементацията на семафора, трябва да се увериш, че е инициализиран (на 0, т.е. да блокира при първи pend), преди да го ползват двата процеса :)

П.П. Аз все така настоявам, че по условие трябва да ползваш обща памет с размер 1 число. :D

 

 

  • Харесва ми 1

Сподели този отговор


Линк към този отговор
Сподели в други сайтове

Регистрирайте се или влезете в профила си за да коментирате

Трябва да имате регистрация за да може да коментирате това

Регистрирайте се

Създайте нова регистрация в нашия форум. Лесно е!

Нова регистрация

Вход

Имате регистрация? Влезте от тук.

Вход

×

Информация

Поставихме бисквитки на устройството ви за най-добро потребителско изживяване. Можете да промените настройките си за бисквитки, или в противен случай приемаме, че сте съгласни с нашите условия за ползване.