InnoDB: Remove unused module sync0ipm

innobase/include/Makefile.am

@@ -44,7 +44,7 @@ noinst_HEADERS = btr0btr.h btr0btr.ic btr0cur.h btr0cur.ic \
         row0types.h row0uins.h row0uins.ic row0umod.h row0umod.ic \
         row0undo.h row0undo.ic row0upd.h row0upd.ic row0vers.h \
         row0vers.ic srv0que.h srv0srv.h srv0srv.ic srv0start.h \
-        sync0arr.h sync0arr.ic sync0ipm.h sync0ipm.ic sync0rw.h \
+        sync0arr.h sync0arr.ic sync0rw.h \
         sync0rw.ic sync0sync.h sync0sync.ic sync0types.h \
         thr0loc.h thr0loc.ic trx0purge.h trx0purge.ic trx0rec.h \
         trx0rec.ic trx0roll.h trx0roll.ic trx0rseg.h trx0rseg.ic \

innobase/include/sync0ipm.h

-/******************************************************
-A fast mutex for interprocess synchronization.
-mutex_t can be used only within single process,
-but ip mutex also between processes.
-
-(c) 1995 Innobase Oy
-
-Created 9/30/1995 Heikki Tuuri
-*******************************************************/
-
-#ifndef sync0ipm_h
-#define sync0ipm_h
-
-#include "univ.i"
-#include "os0sync.h"
-#include "sync0sync.h"
-
-typedef struct ip_mutex_hdl_struct	ip_mutex_hdl_t;
-typedef struct ip_mutex_struct		ip_mutex_t;
-
-/* NOTE! The structure appears here only for the compiler to
-know its size. Do not use its fields directly!
-The structure used in a fast implementation of
-an interprocess mutex. */
-
-struct ip_mutex_struct {
-	mutex_t		mutex;		/* Ordinary mutex struct */
-	ulint		waiters;	/* This field is set to 1 if
-					there may be waiters */
-};
-
-/* The performance of the ip mutex in NT depends on how often
-a thread has to suspend itself waiting for the ip mutex
-to become free. The following variable counts system calls
-involved. */
-
-extern ulint	ip_mutex_system_call_count;
-
-/**********************************************************************
-Creates, or rather, initializes
-an ip mutex object in a specified shared memory location (which must be
-appropriately aligned). The ip mutex is initialized in the reset state.
-NOTE! Explicit destroying of the ip mutex with ip_mutex_free
-is not recommended
-as the mutex resides in shared memory and we cannot make sure that
-no process is currently accessing it. Therefore just use
-ip_mutex_close to free the operating system event and mutex. */
-
-ulint
-ip_mutex_create(
-/*============*/
-					/* out: 0 if succeed */
-	ip_mutex_t*	ip_mutex,	/* in: pointer to shared memory */
-	char*		name,		/* in: name of the ip mutex */
-	ip_mutex_hdl_t** handle);	/* out, own: handle to the
-					created mutex; handle exists
-					in the private address space of
-					the calling process */
-/**********************************************************************
-NOTE! Using this function is not recommended. See the note
-on ip_mutex_create. Destroys an ip mutex */
-
-void
-ip_mutex_free(
-/*==========*/
-	ip_mutex_hdl_t*	handle);		/* in, own: ip mutex handle */
-/**********************************************************************
-Opens an ip mutex object in a specified shared memory location.
-Explicit closing of the ip mutex with ip_mutex_close is necessary to
-free the operating system event and mutex created, and the handle. */
-
-ulint
-ip_mutex_open(
-/*==========*/
-					/* out: 0 if succeed */
-	ip_mutex_t*	ip_mutex,	/* in: pointer to shared memory */
-	char*		name,		/* in: name of the ip mutex */
-	ip_mutex_hdl_t** handle);	/* out, own: handle to the
-					opened mutex */
-/**********************************************************************
-Closes an ip mutex. */
-
-void
-ip_mutex_close(
-/*===========*/
-	ip_mutex_hdl_t*	handle);	/* in, own: ip mutex handle */
-/******************************************************************
-Reserves an ip mutex. */
-UNIV_INLINE
-ulint
-ip_mutex_enter(
-/*===========*/
-					/* out: 0 if success, 
-					SYNC_TIME_EXCEEDED if timeout */
-	ip_mutex_hdl_t*	ip_mutex_hdl,	/* in: pointer to ip mutex handle */
-	ulint		time);		/* in: maximum time to wait, in
-					microseconds, or 
-					SYNC_INFINITE_TIME */
-/******************************************************************
-Releases an ip mutex. */
-UNIV_INLINE
-void
-ip_mutex_exit(
-/*==========*/
-	ip_mutex_hdl_t*	ip_mutex_hdl);	/* in: pointer to ip mutex handle */
-
-
-
-#ifndef UNIV_NONINL
-#include "sync0ipm.ic"
-#endif
-
-#endif

innobase/include/sync0ipm.ic

-/******************************************************
-A fast mutex for interprocess synchronization.
-mutex_t can be used only within single process,
-but ip_mutex_t also between processes.
-
-(c) 1995 Innobase Oy
-
-Created 9/30/1995 Heikki Tuuri
-*******************************************************/
-
-/* An extra structure created in the private address space of each process
-which creates or opens the ip mutex. */
-
-struct ip_mutex_hdl_struct {
-	ip_mutex_t*	ip_mutex;	/* pointer to ip mutex */
-	os_event_t	released;	/* event which signals that the mutex
-					is released; this is obtained from
-					create or open of an ip mutex */
-	os_mutex_t	exclude;	/* os mutex obtained when ip mutex is
-					created or opened */
-};
-
-
-UNIV_INLINE
-ulint
-ip_mutex_get_waiters(
-volatile ip_mutex_t*	ipm);
-UNIV_INLINE
-void
-ip_mutex_set_waiters(
-volatile ip_mutex_t*	ipm,
-	ulint		flag);
-UNIV_INLINE
-mutex_t*
-ip_mutex_get_mutex(
-	ip_mutex_t*	ipm);
-
-
-/******************************************************************
-Accessor functions for ip mutex. */
-UNIV_INLINE
-ulint
-ip_mutex_get_waiters(
-volatile ip_mutex_t*	ipm)
-{
-	return(ipm->waiters);
-}
-UNIV_INLINE
-void
-ip_mutex_set_waiters(
-volatile ip_mutex_t*	ipm,
-	ulint		flag)
-{
-	ipm->waiters = flag;
-}
-UNIV_INLINE
-mutex_t*
-ip_mutex_get_mutex(
-	ip_mutex_t*	ipm)
-{
-	return(&(ipm->mutex));
-}
-
-/******************************************************************
-Reserves an ip mutex. */
-UNIV_INLINE
-ulint
-ip_mutex_enter(
-/*===========*/
-					/* out: 0 if success, 
-					SYNC_TIME_EXCEEDED if timeout */
-	ip_mutex_hdl_t*	ip_mutex_hdl,	/* in: pointer to ip mutex handle */
-	ulint		time)		/* in: maximum time to wait, in
-					microseconds, or 
-					SYNC_INFINITE_TIME */
-{
-	mutex_t*	mutex;
-	os_event_t	released;
-	os_mutex_t	exclude;
-	ip_mutex_t*	ip_mutex;
-	ulint		loop_count;
-	ulint		ret;
-
-	ip_mutex = ip_mutex_hdl->ip_mutex;
-	released = ip_mutex_hdl->released;
-	exclude = ip_mutex_hdl->exclude;
-
-	mutex = ip_mutex_get_mutex(ip_mutex);
-
-	loop_count = 0;
-loop:
-	loop_count++;
-	ut_ad(loop_count < 15);
-
-	if (mutex_enter_nowait(mutex, IB__FILE__, __LINE__) == 0) {
-		/* Succeeded! */
-
-		return(0);
-	}
-	
-	ip_mutex_system_call_count++;
-
-	os_event_reset(released);
-
-	/* Order is important here: FIRST reset event, then set waiters */
-	ip_mutex_set_waiters(ip_mutex, 1);
-
-	if (mutex_enter_nowait(mutex, IB__FILE__, __LINE__) == 0) {
-		/* Succeeded! */
-
-		return(0);
-	}
-
-	if (time == SYNC_INFINITE_TIME) {
-		time = OS_SYNC_INFINITE_TIME;
-	}
-
-	/* Suspend to wait for release */
-
-	ip_mutex_system_call_count++;
-
-	ret = os_event_wait_time(released, time);
-
-	ip_mutex_system_call_count++;
-
-	os_mutex_enter(exclude);
-	ip_mutex_system_call_count++;
-	os_mutex_exit(exclude);
-
-	if (ret != 0) {
-		ut_a(ret == OS_SYNC_TIME_EXCEEDED);
-
-		return(SYNC_TIME_EXCEEDED);
-	}
-
-	goto loop;
-}
-
-/******************************************************************
-Releases an ip mutex. */
-UNIV_INLINE
-void
-ip_mutex_exit(
-/*==========*/
-	ip_mutex_hdl_t*	ip_mutex_hdl)	/* in: pointer to ip mutex handle */
-{
-	mutex_t*	mutex;
-	os_event_t	released;
-	os_mutex_t	exclude;
-	ip_mutex_t*	ip_mutex;
-
-	ip_mutex = ip_mutex_hdl->ip_mutex;
-	released = ip_mutex_hdl->released;
-	exclude = ip_mutex_hdl->exclude;
-
-	mutex = ip_mutex_get_mutex(ip_mutex);
-
-	mutex_exit(mutex);
-
-	if (ip_mutex_get_waiters(ip_mutex) != 0) {
-		
-		ip_mutex_set_waiters(ip_mutex, 0);
-
-		/* Order is important here: FIRST reset waiters, 
-		then set event */
-
-		ip_mutex_system_call_count++;
-		os_mutex_enter(exclude);					
-
-		/* The use of the exclude mutex seems to prevent some
-		kind of a convoy problem in the test tsproc.c. We do
-		not know why. */
-
-		ip_mutex_system_call_count++;
-
-		os_event_set(released);
-	
-		ip_mutex_system_call_count++;
-
-		os_mutex_exit(exclude);
-	}
-}

innobase/sync/Makefile.am

@@ -19,6 +19,6 @@ include ../include/Makefile.i
 
 noinst_LIBRARIES =	libsync.a
 
-libsync_a_SOURCES =	sync0arr.c sync0ipm.c sync0rw.c sync0sync.c
+libsync_a_SOURCES =	sync0arr.c sync0rw.c sync0sync.c
 
 EXTRA_PROGRAMS =	

innobase/sync/makefilewin

 include ..\include\makefile.i
 
-sync.lib: sync0sync.obj sync0rw.obj sync0ipm.obj sync0arr.obj
-	lib -out:..\libs\sync.lib sync0sync.obj sync0rw.obj sync0ipm.obj sync0arr.obj
+sync.lib: sync0sync.obj sync0rw.obj sync0arr.obj
+	lib -out:..\libs\sync.lib sync0sync.obj sync0rw.obj sync0arr.obj
 
 sync0sync.obj: sync0sync.c
 	$(CCOM) $(CFLN) -c sync0sync.c
@@ -9,9 +9,6 @@ sync0sync.obj: sync0sync.c
 sync0rw.obj: sync0rw.c
 	$(CCOM) $(CFL) -c sync0rw.c
 
-sync0ipm.obj: sync0ipm.c
-	$(CCOM) $(CFL) -c sync0ipm.c
-
 sync0arr.obj: sync0arr.c
 	$(CCOM) $(CFL) -c sync0arr.c
 

innobase/sync/sync0ipm.c

-/******************************************************
-A fast mutex for interprocess synchronization.
-mutex_t can be used only within single process,
-but ip_mutex_t also between processes.
-
-(c) 1995 Innobase Oy
-
-Created 9/30/1995 Heikki Tuuri
-*******************************************************/
-#include "sync0ipm.h"
-#ifdef UNIV_NONINL
-#include "sync0ipm.ic"
-#endif
-
-#include "mem0mem.h"
-
-/* The performance of the ip mutex in NT depends on how often
-a thread has to suspend itself waiting for the ip mutex
-to become free. The following variable counts system calls
-involved. */
-
-ulint	ip_mutex_system_call_count	= 0;
-
-/**********************************************************************
-Creates, or rather, initializes
-an ip mutex object in a specified shared memory location (which must be
-appropriately aligned). The ip mutex is initialized in the reset state.
-NOTE! Explicit destroying of the ip mutex with ip_mutex_free
-is not recommended
-as the mutex resides in shared memory and we cannot make sure that
-no process is currently accessing it. Therefore just use
-ip_mutex_close to free the operating system event and mutex. */
-
-ulint
-ip_mutex_create(
-/*============*/
-					/* out: 0 if succeed */
-	ip_mutex_t*	ip_mutex,	/* in: pointer to shared memory */
-	char*		name,		/* in: name of the ip mutex */
-	ip_mutex_hdl_t** handle)	/* out, own: handle to the
-					created mutex; handle exists
-					in the private address space of
-					the calling process */
-{
-	mutex_t*	mutex;
-	char*		buf;
-	os_event_t	released;
-	os_mutex_t	exclude;
-	
-	ip_mutex_set_waiters(ip_mutex, 0);
-
-	buf = mem_alloc(strlen(name) + 20);
-
-	strcpy(buf, name);
-	strcpy(buf + strlen(name), "_IB_RELS");
-
-	released = os_event_create(buf);
-
-	if (released == NULL) {
-		mem_free(buf);
-		return(1);
-	}
-
-	strcpy(buf + strlen(name), "_IB_EXCL");
-
-	exclude = os_mutex_create(buf);
-
-	if (exclude == NULL) {
-		os_event_free(released);
-		mem_free(buf);
-		return(1);
-	}
-
-	mutex = ip_mutex_get_mutex(ip_mutex);
-
-	mutex_create(mutex);
-	mutex_set_level(mutex, SYNC_NO_ORDER_CHECK);
-	
-	*handle = mem_alloc(sizeof(ip_mutex_hdl_t));
-
-	(*handle)->ip_mutex = ip_mutex;
-	(*handle)->released = released;
-	(*handle)->exclude = exclude;
-
-	mem_free(buf);
-
-	return(0);
-}
-
-/**********************************************************************
-NOTE! Using this function is not recommended. See the note
-on ip_mutex_create. Destroys an ip mutex */
-
-void
-ip_mutex_free(
-/*==========*/
-	ip_mutex_hdl_t*	handle)		/* in, own: ip mutex handle */
-{
-	mutex_free(ip_mutex_get_mutex(handle->ip_mutex));
-
-	os_event_free(handle->released);
-	os_mutex_free(handle->exclude);
-
-	mem_free(handle);
-}
-
-/**********************************************************************
-Opens an ip mutex object in a specified shared memory location.
-Explicit closing of the ip mutex with ip_mutex_close is necessary to
-free the operating system event and mutex created, and the handle. */
-
-ulint
-ip_mutex_open(
-/*==========*/
-					/* out: 0 if succeed */
-	ip_mutex_t*	ip_mutex,	/* in: pointer to shared memory */
-	char*		name,		/* in: name of the ip mutex */
-	ip_mutex_hdl_t** handle)	/* out, own: handle to the
-					opened mutex */
-{
-	char*		buf;
-	os_event_t	released;
-	os_mutex_t	exclude;
-	
-	buf = mem_alloc(strlen(name) + 20);
-
-	strcpy(buf, name);
-	strcpy(buf + strlen(name), "_IB_RELS");
-
-	released = os_event_create(buf);
-
-	if (released == NULL) {
-		mem_free(buf);
-		return(1);
-	}
-
-	strcpy(buf + strlen(name), "_IB_EXCL");
-
-	exclude = os_mutex_create(buf);
-
-	if (exclude == NULL) {
-		os_event_free(released);
-		mem_free(buf);
-		return(1);
-	}
-
-	*handle = mem_alloc(sizeof(ip_mutex_hdl_t));
-
-	(*handle)->ip_mutex = ip_mutex;
-	(*handle)->released = released;
-	(*handle)->exclude = exclude;
-
-	mem_free(buf);
-
-	return(0);
-}
-
-/**********************************************************************
-Closes an ip mutex. */
-
-void
-ip_mutex_close(
-/*===========*/
-	ip_mutex_hdl_t*	handle)		/* in, own: ip mutex handle */
-{
-	os_event_free(handle->released);
-	os_mutex_free(handle->exclude);
-
-	mem_free(handle);
-}