Здравейте имам задача "Да се състави програма на 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 произволни цели числа.Ако може малко помощ ще съм благодарен

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

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

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

преди 16 минути, notorious19 написа:

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

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

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

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

Редактирано 1 декември 20169 г. от 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 служат за синхронизация по алгоритъма на Декер.

Редактирано 1 декември 20169 г. от 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 число.

 

 

Благодаря много, жив и здрав!