---

SHMEM Class Reference

#include <shmem.hh>

Inheritance diagram for SHMEM:

[legend]Collaboration diagram for SHMEM:

[legend]

Public Methods
	SHMEM (char *name, long size, int neutral, key_t key, int m=0)
	SHMEM (char *bufline, char *procline, int set_to_server=0, int set_to_master=0)
virtual	~SHMEM ()
CMS_STATUS	main_access (void *_local)
Private Types
enum	SHMEM_MUTEX_TYPE {   NO_MUTEX, MAO_MUTEX, MAO_MUTEX_W_OS_SEM, OS_SEM_MUTEX,   NO_INTERRUPTS_MUTEX, NO_SWITCHING_MUTEX }
Private Methods
int	open ()
int	close ()
Private Attributes
int	fast_mode
key_t	key
key_t	bsem_key
int	second_read
RCS_SHAREDMEM *	shm
RCS_SEMAPHORE *	sem
int	master
double	sem_delay
mem_access_object	mao
int	use_os_sem
int	use_os_sem_only
SHMEM_MUTEX_TYPE	mutex_type
void *	shm_addr_offset
RCS_SEMAPHORE *	bsem
int	autokey_table_size

---

Member Enumeration Documentation

enum SHMEM::SHMEM_MUTEX_TYPE [private]

Enumeration values: NO_MUTEX  MAO_MUTEX  MAO_MUTEX_W_OS_SEM  OS_SEM_MUTEX  NO_INTERRUPTS_MUTEX  NO_SWITCHING_MUTEX  Definition at line 88 of file shmem.hh. { NO_MUTEX, MAO_MUTEX, MAO_MUTEX_W_OS_SEM, OS_SEM_MUTEX, NO_INTERRUPTS_MUTEX, NO_SWITCHING_MUTEX };

---

Constructor & Destructor Documentation

SHMEM::SHMEM (  char *    n, long    s, int    nt, key_t    k, int    m = 0 )

Definition at line 105 of file shmem.cc. : CMS (s) { /* Set pointers to null so only properly opened pointers are closed. */ shm = NULL; // sem = NULL; /* save constructor args */ master = m; key = k; /* open the shared mem buffer and create mutual exclusion semaphore */ open (); }

SHMEM::SHMEM (  char *    bufline, char *    procline, int    set_to_server = 0, int    set_to_master = 0 )

Definition at line 121 of file shmem.cc. : CMS (bufline, procline, set_to_server) { /* Set pointers to null so only properly opened pointers are closed. */ shm = NULL; sem = NULL; sem_delay = 0.00001; char *semdelay_equation; use_os_sem = 1; use_os_sem_only = 1; mutex_type = OS_SEM_MUTEX; bsem_key = -1; second_read = 0; if (status < 0) { rcs_print_error ("SHMEM: status = %d\n", status); return; } /* Save parameters from configuration file. */ #ifndef UNDER_CE if (sscanf (bufline, "%*s %*s %*s %*s %*s %*s %*s %*s %*s %d", &key) != 1) { rcs_print_error ("SHMEM: Invalid configuration file format.\n"); return; } #else char *word[32]; if (separate_words (word, 10, bufline) != 10) { rcs_print_error ("CMS: Error in buffer line from config file.\n"); rcs_print_error ("%s\n", bufline); status = CMS_CONFIG_ERROR; return; } key = atol (word[9]); #endif master = is_local_master; if (1 == set_to_master) { master = 1; } else if (-1 == set_to_master) { master = 0; } #ifndef UNDER_CE if (NULL != (semdelay_equation = strstr (proclineupper, "SEMDELAY="))) { sem_delay = strtod (semdelay_equation + 9, (char **) NULL); } else if (NULL != (semdelay_equation = strstr (buflineupper, "SEMDELAY="))) { sem_delay = strtod (semdelay_equation + 9, (char **) NULL); } #endif if (NULL != (semdelay_equation = strstr (buflineupper, "BSEM="))) { #ifndef UNDER_CE bsem_key = strtol (semdelay_equation + 5, (char **) NULL, 0); #else bsem_key = atol (semdelay_equation + 5); #endif } if (NULL != strstr (buflineupper, "MUTEX=NONE")) { mutex_type = NO_MUTEX; use_os_sem = 0; use_os_sem_only = 0; } if (NULL != strstr (buflineupper, "MUTEX=OS_SEM")) { mutex_type = OS_SEM_MUTEX; use_os_sem = 1; use_os_sem_only = 1; } if (NULL != strstr (buflineupper, "MUTEX=NO_INTERRUPTS")) { mutex_type = NO_INTERRUPTS_MUTEX; use_os_sem = 0; use_os_sem_only = 0; } if (NULL != strstr (buflineupper, "MUTEX=NO_SWITCHING")) { mutex_type = NO_SWITCHING_MUTEX; #ifdef lynxosPC if (fa_ptr == NULL) { fa_ptr = fast_info_attach ((char *) 0xC0000000); } #endif use_os_sem = 0; use_os_sem_only = 0; } if (NULL != strstr (buflineupper, "MUTEX=MAO")) { mutex_type = MAO_MUTEX; use_os_sem = 0; use_os_sem_only = 0; } if (NULL != strstr (buflineupper, "MAO_W_OS_SEM")) { mutex_type = MAO_MUTEX_W_OS_SEM; use_os_sem = 1; use_os_sem_only = 0; } /* Open the shared memory buffer and create mutual exclusion semaphore. */ open (); }

SHMEM::~SHMEM (    )  [virtual]

Definition at line 243 of file shmem.cc. { /* detach from shared memory and semaphores */ close (); }

---

Member Function Documentation

CMS_STATUS SHMEM::main_access (  void *    _local )  [virtual]

Reimplemented from CMS. Definition at line 641 of file shmem.cc. { #if defined(LYNX) && !defined(lynxosPC) int interrupt_disable_number = 0; int switching_disable_number = 1; #endif /* Check pointers. */ if (shm == NULL) { second_read = 0; return (status = CMS_MISC_ERROR); } if (bsem == NULL && not_zero (blocking_timeout)) { rcs_print_error ("No blocking semaphore available. Can not call blocking_read(%f).\n", blocking_timeout); second_read = 0; return (status = CMS_NO_BLOCKING_SEM_ERROR); } mao.read_only = ((internal_access_type == CMS_CHECK_IF_READ_ACCESS) || (internal_access_type == CMS_PEEK_ACCESS) || (internal_access_type == CMS_READ_ACCESS)); #ifdef VXWORKS int intLockKey = 0; #endif switch (mutex_type) { case NO_MUTEX: break; case MAO_MUTEX: case MAO_MUTEX_W_OS_SEM: switch (mem_get_access (&mao)) { case -1: rcs_print_error ("SHMEM: Can't take semaphore\n"); second_read = 0; return (status = CMS_MISC_ERROR); case -2: if (timeout > 0) { rcs_print_error ("SHMEM: Timed out waiting for semaphore.\n"); rcs_print_error ("buffer = %s, timeout = %lf sec.\n", BufferName, timeout); } second_read = 0; return (status = CMS_TIMED_OUT); default: break; } toggle_bit = mao.toggle_bit; break; case OS_SEM_MUTEX: if (sem == NULL) { second_read = 0; return (status = CMS_MISC_ERROR); } switch (sem->wait ()) { case -1: rcs_print_error ("SHMEM: Can't take semaphore\n"); second_read = 0; return (status = CMS_MISC_ERROR); case -2: if (timeout > 0) { rcs_print_error ("SHMEM: Timed out waiting for semaphore.\n"); rcs_print_error ("buffer = %s, timeout = %lf sec.\n", BufferName, timeout); } second_read = 0; return (status = CMS_TIMED_OUT); default: break; } break; case NO_INTERRUPTS_MUTEX: #ifdef LYNX disable (interrupt_disable_number); break; #else #ifdef VXWORKS intLockKey = intLock (); break; #else rcs_print_error ("Interrupts can not be disabled.\n"); second_read = 0; return (status = CMS_MISC_ERROR); break; #endif #endif case NO_SWITCHING_MUTEX: #ifdef lynxosPC fa_ptr->preempt++; break; #else #if 0 // The LYNX documentation says this should work but the // symbol sdisable is not available. sdisable (switching_disable_number); break; #else #ifdef VXWORKS taskLock (); break; #else rcs_print_error ("Interrupts can not be disabled.\n"); return (status = CMS_MISC_ERROR); break; #endif #endif #endif default: rcs_print_error ("SHMEM: Invalid mutex type.(%d)\n", mutex_type); second_read = 0; return (status = CMS_MISC_ERROR); break; } if (second_read > 0 && enable_diagnostics) { disable_diag_store = 1; } /* Perform access function. */ internal_access (shm->addr, size, _local); disable_diag_store = 0; if (NULL != bsem && (internal_access_type == CMS_WRITE_ACCESS || internal_access_type == CMS_WRITE_IF_READ_ACCESS)) { #ifndef WIN32 bsem->flush (); #else if (!PulseEvent (bsem)) { rcs_print_sys_error (GETLASTERROR_ERROR_SOURCE, "PulseEvent error"); } #endif } switch (mutex_type) { case NO_MUTEX: break; case MAO_MUTEX: case MAO_MUTEX_W_OS_SEM: mem_release_access (&mao); break; case OS_SEM_MUTEX: sem->post (); break; case NO_INTERRUPTS_MUTEX: #ifdef LYNX restore (interrupt_disable_number); break; #else #ifdef VXWORKS intUnlock (intLockKey); #else rcs_print_error ("Can not restore interrupts.\n"); break; #endif #endif case NO_SWITCHING_MUTEX: #ifdef lynxosPC if ((!(--(fa_ptr->preempt)) || fa_ptr->preempt > 0x40) && fa_ptr->flag) { fast_enable_preemption (); } break; #else #if 0 // The LYNX documentation says this should work but // the symbol srestore is not available. srestore (switching_disable_number); break; #else #ifdef VXWORKS taskUnlock (); break; #else rcs_print_error ("Can not restore interrupts.\n"); break; #endif #endif #endif } switch (internal_access_type) { case CMS_READ_ACCESS: if (NULL != bsem && status == CMS_READ_OLD && (blocking_timeout > 1e-6 || blocking_timeout < -1E-6)) { if (second_read > 10 && total_subdivisions <= 1) { status = CMS_MISC_ERROR; rcs_print_error ("CMS: Blocking semaphore error. The semaphore wait has returned %d times but there is still no new data.\n", second_read); second_read = 0; return (status); } #ifndef WIN32 second_read++; bsem->timeout = blocking_timeout; #if !defined(VXWORKS) && !defined(WIN32) sem_force_fifo = 1; #endif int bsem_ret = bsem->wait (); #if !defined(VXWORKS) && !defined(WIN32) sem_force_fifo = 0; #endif if (bsem_ret == -2) { status = CMS_TIMED_OUT; second_read = 0; return (status); } if (bsem_ret == -1) { rcs_print_error ("CMS: Blocking semaphore error.\n"); status = CMS_MISC_ERROR; second_read = 0; return (status); } #else DWORD timeoutMillis = (DWORD) (blocking_timeout * 1000.0); if (blocking_timeout < 0) { timeoutMillis = INFINITE; } switch (WaitForSingleObject (bsem, timeoutMillis)) { case WAIT_TIMEOUT: status = CMS_TIMED_OUT; second_read = 0; return (status); case WAIT_OBJECT_0: second_read++; break; default: rcs_print_sys_error (GETLASTERROR_ERROR_SOURCE, "WaitForSingleObject error"); status = CMS_MISC_ERROR; second_read = 0; return (status); } #endif main_access (_local); } break; case CMS_WRITE_ACCESS: case CMS_WRITE_IF_READ_ACCESS: #if 0 if (NULL != bsem) { #ifndef WIN32 bsem->flush (); #else if (!PulseEvent (bsem)) { rcs_print_sys_error (GETLASTERROR_ERROR_SOURCE, "PulseEvent error"); } #endif } #endif break; default: break; } second_read = 0; return (status); }

int SHMEM::open (  void    )  [private]

Reimplemented from CMS. Definition at line 253 of file shmem.cc. Referenced by SHMEM(). { /* Set pointers to NULL incase error occurs. */ sem = NULL; shm = NULL; bsem = NULL; shm_addr_offset = NULL; second_read = 0; autokey_table_size = 0; if (use_autokey_for_connection_number) { autokey_table_size = sizeof (AUTOKEY_TABLE_ENTRY) * total_connections; } /* set up the shared memory address and semaphore, in given state */ if (master) { shm = new RCS_SHAREDMEM (key, size, RCS_SHAREDMEM_CREATE, (int) MODE); if (shm->addr == NULL) { switch (shm->create_errno) { #ifndef UNDER_CE case EACCES: status = CMS_PERMISSIONS_ERROR; break; case EEXIST: status = CMS_RESOURCE_CONFLICT_ERROR; break; case ENOMEM: case ENOSPC: status = CMS_CREATE_ERROR; break; #endif default: status = CMS_MISC_ERROR; } delete shm; shm = NULL; return -1; } if (use_os_sem) { sem = new RCS_SEMAPHORE (key, RCS_SEMAPHORE_CREATE, timeout, (int) MODE, (use_os_sem_only != 0)); if (NULL == sem) { rcs_print_error ("CMS: couldn't create RCS_SEMAPHORE.\n"); rcs_print_error (" Possibly out of memory?\n"); status = CMS_CREATE_ERROR; return -1; } if (!sem->valid ()) { rcs_print_error ("CMS: RCS_SEMAPHORE is invalid.\n"); status = CMS_MISC_ERROR; return -1; } } if (bsem_key > 0) { #ifndef WIN32 bsem = new RCS_SEMAPHORE (bsem_key, RCS_SEMAPHORE_CREATE, timeout, (int) MODE, 0); if (NULL == bsem) { rcs_print_error ("CMS: couldn't create RCS_SEMAPHORE.\n"); rcs_print_error (" Possibly out of memory?\n"); status = CMS_CREATE_ERROR; return -1; } if (!bsem->valid ()) { rcs_print_error ("CMS: RCS_SEMAPHORE is invalid.\n"); status = CMS_MISC_ERROR; return -1; } #else char bsem_event_name[80]; #ifndef NO_STDIO sprintf (bsem_event_name, "event%d", bsem_key); #else strcpy (bsem_event_name, "event"); _itoa (bsem_key, bsem_event_name + 5, 10); #endif #ifndef UNDER_CE SECURITY_ATTRIBUTES sa; SECURITY_DESCRIPTOR sd; if (FALSE == InitializeSecurityDescriptor (&sd, SECURITY_DESCRIPTOR_REVISION)) { rcs_print_sys_error (GETLASTERROR_ERROR_SOURCE, "Can not initailize security descriptor.\n"); status = CMS_MISC_ERROR; return -1; } sa.nLength = sizeof (SECURITY_ATTRIBUTES); sa.lpSecurityDescriptor = &sd; sa.bInheritHandle = TRUE; bsem = CreateEvent (&sa, TRUE, FALSE, bsem_event_name); #else #ifdef UNICODE wchar_t wbsem_event_name[80]; RCS_CE_ASCII_TO_UNICODE (wbsem_event_name, bsem_event_name, 80); bsem = CreateEvent (NULL, TRUE, FALSE, wbsem_event_name); #else bsem = CreateEvent (NULL, TRUE, FALSE, bsem_event_name); #endif #endif if (NULL == bsem) { rcs_print_sys_error (GETLASTERROR_ERROR_SOURCE, "CreateEvent error:"); } #endif } in_buffer_id = 0; } else { shm = new RCS_SHAREDMEM (key, size, RCS_SHAREDMEM_NOCREATE); if (NULL == shm) { rcs_print_error ("CMS: couldn't create RCS_SHAREDMEM(%d(0x%X), %d(0x%X), RCS_SHAREDMEM_NOCREATE).\n", key, key, size, size); status = CMS_CREATE_ERROR; return -1; } if (shm->addr == NULL) { switch (shm->create_errno) { #ifndef UNDER_CE case EACCES: status = CMS_PERMISSIONS_ERROR; break; case EEXIST: status = CMS_RESOURCE_CONFLICT_ERROR; break; case ENOENT: status = CMS_NO_MASTER_ERROR; break; case ENOMEM: case ENOSPC: status = CMS_CREATE_ERROR; break; #endif default: status = CMS_MISC_ERROR; } delete shm; shm = NULL; return -1; } if (use_os_sem) { sem = new RCS_SEMAPHORE (key, RCS_SEMAPHORE_NOCREATE, timeout); if (NULL == sem) { rcs_print_error ("CMS: couldn't create RCS_SEMAPHORE.\n"); rcs_print_error (" Possibly out of memory?\n"); status = CMS_CREATE_ERROR; return -1; } if (!sem->valid ()) { rcs_print_error ("CMS: RCS_SEMAPHORE is invalid.\n"); status = CMS_MISC_ERROR; return -1; } } if (bsem_key > 0) { #ifndef WIN32 bsem = new RCS_SEMAPHORE (bsem_key, RCS_SEMAPHORE_NOCREATE, timeout); if (NULL == bsem) { rcs_print_error ("CMS: couldn't create RCS_SEMAPHORE.\n"); rcs_print_error (" Possibly out of memory?\n"); status = CMS_CREATE_ERROR; return -1; } if (!bsem->valid ()) { rcs_print_error ("CMS: RCS_SEMAPHORE is invalid.\n"); status = CMS_MISC_ERROR; return -1; } #else char bsem_event_name[80]; #ifndef NO_STDIO sprintf (bsem_event_name, "event%d", bsem_key); #else strcpy (bsem_event_name, "event"); _itoa (bsem_key, bsem_event_name + 5, 10); #endif #ifndef UNDER_CE bsem = OpenEvent (EVENT_ALL_ACCESS, TRUE, bsem_event_name); #else #ifdef UNICODE wchar_t wbsem_event_name[80]; RCS_CE_ASCII_TO_UNICODE (wbsem_event_name, bsem_event_name, 80); bsem = CreateEvent (NULL, TRUE, FALSE, wbsem_event_name); #else bsem = CreateEvent (NULL, TRUE, FALSE, bsem_event_name); #endif #endif if (NULL == bsem) { rcs_print_sys_error (GETLASTERROR_ERROR_SOURCE, "OpenEvent error:"); } #endif } } if (min_compatible_version < 3.44 && min_compatible_version > 0) { total_subdivisions = 1; } if (min_compatible_version > 2.57 || min_compatible_version <= 0) { if (!shm->created) { char *cptr = (char *) shm->addr; cptr[31] = 0; if (strncmp (cptr, BufferName, 31)) { rcs_print_error ("Shared memory buffers %s and %s may conflict. (key=%d(0x%X))\n", BufferName, cptr, key, key); strncpy (cptr, BufferName, 32); } } if (master) { if (use_autokey_for_connection_number) { void *autokey_table_end = (void *) (((char *) shm->addr) + 32 + autokey_table_size); memset (autokey_table_end, 0, size - 32 - autokey_table_size); } strncpy ((char *) shm->addr, BufferName, 32); } if (use_autokey_for_connection_number) { void *autokey_table = (void *) (((char *) shm->addr) + 32); connection_number = autokey_getkey (autokey_table, total_connections, ProcessName); shm_addr_offset = (void *) ((char *) (shm->addr) + 32 + autokey_table_size); max_message_size -= (32 + autokey_table_size); /* size of cms buffer available for user */ } else { shm_addr_offset = (void *) ((char *) (shm->addr) + 32); max_message_size -= 32; /* size of cms buffer available for user */ } /* messages = size - CMS Header space */ if (enc_max_size <= 0 || enc_max_size > size) { if (neutral) { max_encoded_message_size -= 32; } else { max_encoded_message_size -= (cms_encoded_data_explosion_factor * 32); } } /* Maximum size of message after being encoded. */ guaranteed_message_space -= 32; /* Largest size message before being encoded that can be guaranteed to fit after xdr. */ size -= 32; size_without_diagnostics -= 32; subdiv_size = (size_without_diagnostics - total_connections) / total_subdivisions; subdiv_size -= (subdiv_size % 4); } else { if (master) { memset (shm->addr, 0, size); } shm_addr_offset = shm->addr; } skip_area = 32 + total_connections + autokey_table_size; mao.data = shm_addr_offset; mao.timeout = timeout; mao.total_connections = total_connections; mao.sem_delay = sem_delay; mao.connection_number = connection_number; mao.split_buffer = split_buffer; mao.read_only = 0; mao.sem = sem; fast_mode = !queuing_enabled && !split_buffer && !neutral && (mutex_type == NO_SWITCHING_MUTEX); handle_to_global_data = dummy_handle = new PHYSMEM_HANDLE; handle_to_global_data->set_to_ptr (shm_addr_offset, size); if ((connection_number < 0 || connection_number >= total_connections) && (mutex_type == MAO_MUTEX || mutex_type == MAO_MUTEX_W_OS_SEM)) { rcs_print_error ("Bad connection number %d\n", connection_number); status = CMS_MISC_ERROR; return -1; } return 0; }

int SHMEM::close (    )  [private]

Definition at line 582 of file shmem.cc. Referenced by ~SHMEM(). { int nattch = 0; second_read = 0; if (use_autokey_for_connection_number) { void *autokey_table = (void *) (((char *) shm->addr) + 32); autokey_releasekey (autokey_table, total_connections, ProcessName, connection_number); } if (NULL != shm) { /* see if we're the last one */ nattch = shm->nattch (); shm->delete_totally = delete_totally; delete shm; shm = NULL; } if (NULL != sem) { /* if we're the last one, then make us the master so that the semaphore will go away */ if (nattch <= 1 || delete_totally) { sem->setflag (RCS_SEMAPHORE_CREATE); } else { sem->setflag (RCS_SEMAPHORE_NOCREATE); } delete sem; } #ifndef WIN32 if (NULL != bsem) { /* if we're the last one, then make us the master so that the semaphore will go away */ if (nattch <= 1 || delete_totally) { bsem->setflag (RCS_SEMAPHORE_CREATE); } else { bsem->setflag (RCS_SEMAPHORE_NOCREATE); } delete bsem; } #endif #ifdef DEBUG printf ("SHMEM(%s): nattch = %d\n", BufferName, nattch); #endif return 0; }

---

Field Documentation

int SHMEM::fast_mode [private]

Reimplemented from CMS. Definition at line 70 of file shmem.hh.

key_t SHMEM::key [private]

Definition at line 79 of file shmem.hh.

key_t SHMEM::bsem_key [private]

Definition at line 80 of file shmem.hh.

int SHMEM::second_read [private]

Definition at line 81 of file shmem.hh.

RCS_SHAREDMEM* SHMEM::shm [private]

Definition at line 82 of file shmem.hh.

RCS_SEMAPHORE* SHMEM::sem [private]

Definition at line 83 of file shmem.hh.

int SHMEM::master [private]

Definition at line 84 of file shmem.hh.

double SHMEM::sem_delay [private]

Definition at line 86 of file shmem.hh.

struct mem_access_object SHMEM::mao [private]

Definition at line 87 of file shmem.hh.

int SHMEM::use_os_sem [private]

Definition at line 98 of file shmem.hh.

int SHMEM::use_os_sem_only [private]

Definition at line 99 of file shmem.hh.

SHMEM_MUTEX_TYPE SHMEM::mutex_type [private]

Definition at line 101 of file shmem.hh.

void* SHMEM::shm_addr_offset [private]

Definition at line 102 of file shmem.hh.

RCS_SEMAPHORE* SHMEM::bsem [private]

Definition at line 107 of file shmem.hh.

int SHMEM::autokey_table_size [private]

Definition at line 109 of file shmem.hh.

---

The documentation for this class was generated from the following files:

• shmem.hh
• shmem.cc

---