MasterZiv
onstat- пишет:
> почему не будет?
....
> Подскажите где я не прав.

Вот что б я чего-то там понял.

Разве этого не достаточно ?

> 1. Проверяем мютексы на чтение и на запись,
> если кто то пишет, спим пока не освободится.

делаем дело, освобождаем мьютексы.


Posted via ActualForum NNTP Server 1.4

Проблема мютексов в отличие от POSIX семафоров в том что нельзя
атомарно (( косистентно), (за один системный вызов)) проверить и изменить несколько штук( группу).

MasterZiv

Это - изменение не контейнера, а хранимого объекта.
Это уже - проблема самого объекта.
Posted via ActualForum NNTP Server 1.4

Изза одного изменяемого обьекта из 1000 вы предлагаете спать всем, кто
даже не планирует иметь к нему доступ, Хотя это дело личное.

Мое дело предложить, а автору топика решать как быть.

MasterZiv



Разве этого не достаточно ?

onstat- пишет:
> 1. Проверяем мютексы на чтение и на запись,
> если кто то пишет, спим пока не освободится.

делаем дело, освобождаем мьютексы.


MasterZiv

Я не говорил, что их надо одновременно лочить. Сначала один,
на чтение, потом другой, на запись.
Posted via ActualForum NNTP Server 1.4

При установке мютекса на чтение никакая другая сессия через него пройти не сможет.
А как же паралельное чтение? Когда всетаки освобождаем?

OLEG_2005Здесь упоминали семафоры для решения данной задачи, инересно, а каким образом для решения задачи можно применить световоры?

Вот упрощенная версия, работает только в Unix.


[SRC locks.h]

/**************************=-OpenDSA-=******************************

This file is a part of OpenDSA project(http://sourceforge.net/projects/opendsa)
It can be destributed independently of OpenDSA with safe license of
OpenDSA. OpenDSA is destributed by GPL license.
(04.06.2006).
All rights reserved by (C) Konstantin Kaduk 2006.

*******************************************************************/


#include <stdio.h> // standard I/O routines.
#include <sys/types.h> // various type definitions.
#include <sys/ipc.h> // general SysV IPC structures
#include <sys/sem.h> // shared memory functions and structs.
#include <errno.h>
#include <string.h>


/*******************************************************************



*******************************************************************/


#ifndef SEM_LOCK_H
#define SEM_LOCK_H
extern int rc; // any results

#define MAXSETSIZE 3
/*******************************************************************



*******************************************************************/
union semun {
int val; /* value for SETVAL */
struct semid_ds *buf; /* buffer for IPC_STAT, IPC_SET */
unsigned short *array; /* array for GETALL, SETALL */
/* Linux specific part: */
struct seminfo *__buf; /* buffer for IPC_INFO */
};



/*******************************************************************



*******************************************************************/

#define LOC_SEM_CNT 3
class c_lock

/*******************************************************************
Class c_lock provide objects locking for reading and writing

1. READ locking
Any concurent processes can read data which locked by another.
Each process incerase semaphore(0) counter for place reading lock.
When write lock was placed(semaphore(1)) by another process
reading process will sleep while writing lock will be dropped.
Counter is decreased when reding lock is dropped by current process.


2. Write locking
Writing process sleeps while any another process is reading or writing
data now.It wake ups when counter(semaphotre 1) of reading process
is equal to zero. It places writing lock by two semaphores(1,2):
Semaphore 1 is used for place writing lock (using for check by
reading processes).
Semaphore 2 is used for exclusive lock(only one process can use data
at the same time).

////////End of original coment form Konstantin Kaduk ////////////////////////

Remark1:

///////

*******************************************************************/


{
int s_set_id;
struct sembuf s_sem_op[LOC_SEM_CNT];
union semun s_semun;
unsigned short s_semarray[LOC_SEM_CNT]; //array for semop
public:
c_lock(int sem_id=0);
~c_lock();

int lock_init(int sem_id);


void stat(const char* f_comment=NULL ); // print current values of semaphore

void r_lock(); // place reading lock

void r_unlock(); // decrease reading counter

void w_lock(); // place writing lock

void w_unlock(); // drop writing lock


};

#endif

[/src]


[SRC locks.cpp]
/**************************=-OpenDSA-=******************************

This file is a part of OpenDSA project(http://sourceforge.net/projects/opendsa)
It can be destributed independently of OpenDSA with safe license of
OpenDSA. OpenDSA is destributed by GPL license (04.06.2006).

All rights reserved by (C) Konstantin Kaduk 2006.

*******************************************************************/



#include "sem_lock.h"

/******************************************************************

*******************************************************************/

c_lock::c_lock(int sem_id):s_set_id(0)
{
if(sem_id!=0)
lock_init(sem_id);

};

/******************************************************************

*******************************************************************/
c_lock::~c_lock()
{
int rc=semctl(s_set_id, 0, IPC_RMID);
};

/******************************************************************

*******************************************************************/
int c_lock::lock_init(int sem_id)
{
printf("initing semaphore lock [%d]\n", sem_id);

s_set_id = semget(sem_id, 3, IPC_CREAT | 0600);
if(s_set_id==-1)
{
printf("Unable to allocate semaphore errno %d [%s]\n",errno, strerror(errno));
throw int(10);
};
s_semun.array=&s_semarray[0];
s_semarray[0]=0; //reading
s_semarray[1]=0; //writing
s_semarray[2]=1; // spin lock

rc = semctl(s_set_id, 3, SETALL, s_semun );
if(rc == -1)
{
printf("Problem to set sem value %d [%s]\n",errno, strerror(errno));
throw int(11);
};

return 0;
};


/******************************************************************

*******************************************************************/


void c_lock::stat( const char* f_comment)
{
s_semun.array=&s_semarray[0];
int rc = semctl(s_set_id, 0,GETALL, s_semun);

if (f_comment!=NULL) printf("****** %s ******\n", f_comment);
printf("SEM values READ WRITE WRSPIN\n");
printf(" [%d] [%d] [%d] \n", s_semarray[0], s_semarray[1], s_semarray[2]);
printf("*********************************\n");
};

/******************************************************************


*******************************************************************/

void c_lock::r_lock()
{

struct sembuf sem_op;

stat( "before read lock");

//increse for reading
s_sem_op[0].sem_num = 0;
s_sem_op[0].sem_op = 1; //increase read value
s_sem_op[0].sem_flg = 0;//IPC_NOWAIT;
//check for write
s_sem_op[1].sem_num = 1;
s_sem_op[1].sem_op = 0; // check for write
s_sem_op[1].sem_flg = 0;//IPC_NOWAIT;

rc=semop(s_set_id, &s_sem_op[0], 2);
stat("read locked");


};


/******************************************************************

*******************************************************************/


void c_lock::r_unlock()
{
struct sembuf sem_op;
stat("read unlocking");

s_sem_op[0].sem_num = 0;
s_sem_op[0].sem_op = -1; //decrease reading value
s_sem_op[0].sem_flg = 0;

rc=semop(s_set_id, &s_sem_op[0], 1);
stat(" read unlocked");

};

/******************************************************************

*******************************************************************/


void c_lock::w_lock()
{


stat("write locking");

//increse for read
s_sem_op[0].sem_num = 0;
s_sem_op[0].sem_op = 0;
s_sem_op[0].sem_flg = 0;//IPC_NOWAIT;
//check for write
s_sem_op[1].sem_num = 1;
s_sem_op[1].sem_op = 1; // check for write
s_sem_op[1].sem_flg = 0;//IPC_NOWAIT;

s_sem_op[2].sem_num = 2;
s_sem_op[2].sem_op = -1; // set for exclusive
s_sem_op[2].sem_flg = 0;//IPC_NOWAIT;

rc=semop(s_set_id, &s_sem_op[0], 3);

stat("write locked");

};

/******************************************************************

*******************************************************************/


void c_lock::w_unlock()
{
stat("write unlocking");
s_sem_op[1].sem_num = 1;
s_sem_op[1].sem_op = -1;
s_sem_op[1].sem_flg = 0;
s_sem_op[2].sem_num = 2;
s_sem_op[2].sem_op = 1; // check for spin write
s_sem_op[2].sem_flg = 0;//IPC_NOWAIT;


rc=semop(s_set_id, &s_sem_op[1], 2);
stat("write unlocked");

};

[/SRC]