Rx3/libshmem
1
1
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

Compare commits

base: Rx3:libshmem-1_0_0-1
Branches Tags
Rx3:master Rx3:libshmem-2.1
Rx3:libshmem-2.1.0 Rx3:libshmem-1_0_0-1
...
compare: Rx3:8e908f867cd174163b0830f9b925831b9f524b21
Branches Tags
Rx3:master Rx3:libshmem-2.1
Rx3:libshmem-2.1.0 Rx3:libshmem-1_0_0-1

7 Commits
libshmem-1 ... 8e908f867c

Author SHA1 Message Date
agibert
8e908f867c Update managers implementation to libnode 2.x standard, 
Fix some print out,
More debugging needed...
 2005-02-23 23:31:06 +00:00
agibert
cf00c637c7 Support for LibNode 2.1.x. 
Update revision number to 2.0 !
 2005-01-24 23:58:23 +00:00
agibert
b51a87426d Initial creation. 2005-01-24 23:31:01 +00:00
agibert
8b84ce1517 Initial creation. 2005-01-24 23:24:30 +00:00
agibert
4cfc687710 Continue LibNode 2.1.x migration, 
Lot of bugs fixed,
Now compile,
Managers need a lot of fixes...
 2005-01-24 23:10:09 +00:00
agibert
d05bee0900 Initial support for LibNode 2.1.x. 
Not working version...
Update revision number to 2.0 !
 2005-01-24 23:04:42 +00:00
agibert
bb73fb28cc Initial support for LibNode 2.1.x. 
Not working version...
Update revision number to 2.0 !
 2005-01-24 22:57:06 +00:00
16 changed files with 3155 additions and 1017 deletions
Expand all files Collapse all files

25
Makefile Normal file
View File

@@ -0,0 +1,25 @@
# $RCSfile: Makefile,v $
# $Revision: 1.1 $
# $Name: $
# $Date: 2005/01/24 23:24:30 $
# $Author: agibert $
#------------------------------------------------------------------------------
# Main Makefile
#------------------------------------------------------------------------------
SUBDIRS := include lib util doc
FILE_DOC := *.txt
include Makefile.var
include Makefile.rule
dir_clean:
$(RM) $(PROG_VERSION_NAME).src.*

359
Makefile.rule Normal file
View File

@@ -0,0 +1,359 @@
# $RCSfile: Makefile.rule,v $
# $Revision: 1.1 $
# $Name: $
# $Date: 2005/01/24 23:24:30 $
# $Author: agibert $
#------------------------------------------------------------------------------
# Rule Makefile
#------------------------------------------------------------------------------
# ----------------- DEFAULT RULES ---------------------
default:all
# ----------------- IMPLICITES RULES ---------------------
# Here are all the rules allowing to compile sources files
# c -> o
%.o:%.c
$(CC) $(CFLAGS) $(INCLUDE) -c $< -o $@
# c -> executable
.c :
$(CC) $(CFLAGS) $(INCLUDE) $< -o $@ -I . $(LIB)
# o -> executable
%:%.o
$(CC) $(LFLAGS) -o $@ $? $(LIB)
# .o -> .so
%.so:%.o
$(CC) $(LDSOFLAGS) -shared -o $@ $? $(LIB)
%.a:%.o
$(AR) -r $@ $?
$(OBJECTS) : $(SRC)
# "depend" rule allow to build the dependancy file
depend:
# "all" Rule
all: dir_all
ifneq ($(SUBDIRS),)
for d in $(SUBDIRS) ; do $(MAKE) all -C $$d/ ; done
endif
dir_all: $(TARGETS)
# "clean" Rule
clean: dir_clean
ifneq ($(SUBDIRS),)
for d in $(SUBDIRS) ; do $(MAKE) clean -C $$d/ ; done
endif
dir_clean:
@(command="$(RM) $(TARGETS) $$(echo $(SRC) | sed "s/\.c/\.o/g") ;" ; \
echo $$command ; \
eval $$command ;)
# "pre_install" Rule
# This empty rule can be overiden in module Makefile in order to run pre-install commands.
pre_install:
# "post_install" Rule
# This empty rule can be overiden in module Makefile in order to run post-install commands.
post_install:
# "install" Rule
install: dir_install
ifneq ($(SUBDIRS),)
for d in $(SUBDIRS) ; do $(MAKE) install -C $$d/ ; done
endif
dir_install: dir_all
$(MAKE) pre_install
ifneq ($(FILE_BIN),)
@if test ! -d $(PATH_BIN) ; then $(MKDIR) $(PATH_BIN) ; fi
$(INSTALLBIN) $(FILE_BIN) $(PATH_BIN)
endif
ifneq ($(FILE_BINSUID),)
@if test ! -d $(PATH_BINSUID) ; then $(MKDIR) $(PATH_BINSUID) ; fi
$(INSTALLBINSUID) $(FILE_BINSUID) $(PATH_BINSUID)
endif
ifneq ($(FILE_CGI),)
@if test ! -d $(PATH_CGI) ; then $(MKDIR) $(PATH_CGI) ; fi
$(INSTALLCGI) $(FILE_CGI) $(PATH_CGI)
endif
ifneq ($(FILE_DOC),)
@if test ! -d $(PATH_DOC) ; then $(MKDIR) $(PATH_DOC) ; fi
$(INSTALLDOC) $(FILE_DOC) $(PATH_DOC)
endif
ifneq ($(FILE_ETC),)
@if test ! -d $(PATH_ETC) ; then $(MKDIR) $(PATH_ETC) ; fi
$(INSTALLETC) $(FILE_ETC) $(PATH_ETC)
endif
ifneq ($(FILE_HOME),)
@if test ! -d $(PATH_HOME) ; then $(MKDIR) $(PATH_HOME) ; fi
$(INSTALLHOME) $(FILE_HOME) $(PATH_HOME)
endif
ifneq ($(FILE_HOMEBIN),)
@if test ! -d $(PATH_HOMEBIN) ; then $(MKDIR) $(PATH_HOMEBIN) ; fi
$(INSTALLHOMEBIN) $(FILE_HOMEBIN) $(PATH_HOMEBIN)
endif
ifneq ($(FILE_LIB),)
@if test ! -d $(PATH_LIB) ; then $(MKDIR) $(PATH_LIB) ; fi
$(INSTALLLIB) $(FILE_LIB) $(PATH_LIB)
endif
ifneq ($(FILE_HOMELIB),)
@if test ! -d $(PATH_HOMELIB) ; then $(MKDIR) $(PATH_HOMELIB) ; fi
$(INSTALLHOMELIB) $(FILE_HOMELIB) $(PATH_HOMELIB)
endif
ifneq ($(FILE_INCLUDE),)
@if test ! -d $(PATH_INCLUDE) ; then $(MKDIR) $(PATH_INCLUDE) ; fi
$(INSTALLINCLUDE) $(FILE_INCLUDE) $(PATH_INCLUDE)
endif
ifneq ($(FILE_MAN),)
@for d in $(FILE_MAN) ; do \
if test ! -d $(PATH_MAN)/$(FILE_MAN) ; then \
$(MKDIR) $(PATH_MAN)/$(FILE_MAN) ; \
fi ; \
$(INSTALLMAN) $(FILE_MAN)/* $(PATH_MAN)/$(FILE_MAN) ; \
done
endif
ifneq ($(FILE_WEBCONF),)
@if test ! -d $(PATH_WEBCONF) ; then $(MKDIR) $(PATH_WEBCONF) ; fi
$(INSTALLWEBCONF) $(FILE_WEBCONF) $(PATH_WEBCONF)
endif
ifneq ($(FILE_WEBCONFSSL),)
@if test ! -d $(PATH_WEBCONFSSL) ; then $(MKDIR) $(PATH_WEBCONFSSL) ; fi
$(INSTALLWEBCONFSSL) $(FILE_WEBCONFSSL) $(PATH_WEBCONFSSL)
endif
ifneq ($(FILE_HTML),)
@if test ! -d $(PATH_HTML) ; then $(MKDIR) $(PATH_HTML) ; fi
$(INSTALLHTML) $(FILE_HTML) $(PATH_HTML)
endif
ifneq ($(FILE_WEBICONS),)
@if test ! -d $(PATH_WEBICONS) ; then $(MKDIR) $(PATH_WEBICONS) ; fi
$(INSTALLWEBICONS) $(FILE_WEBICONS) $(PATH_WEBICONS)
endif
$(MAKE) post_install
# "pre_uninstall" Rule
# This empty rule can be overiden in module Makefile in order to run pre-uninstall commands.
pre_uninstall:
# "post_uninstall" Rule
# This empty rule can be overiden in module Makefile in order to run post-uninstall commands.
post_uninstall:
# "uninstall" Rule
uninstall: dir_uninstall
ifneq ($(SUBDIRS),)
for d in $(SUBDIRS) ; do $(MAKE) uninstall -C $$d/ ; done
endif
dir_uninstall:
$(MAKE) pre_uninstall
ifneq ($(FILE_BIN),)
@(if test -d $(PATH_BIN) ; then \
$(CD) $(PATH_BIN) ; \
(echo $(MAKEFLAGS) | grep s) > /dev/null ; \
if [ $$? -ne 0 ] ; then \
echo "$(CD) $(PATH_BIN)" ; \
echo "$(RM) $(FILE_BIN)" ; \
fi ; \
$(RM) $(FILE_BIN) ; \
fi)
endif
ifneq ($(FILE_BINSUID),)
@(if test -d $(PATH_BINSUID) ; then \
$(CD) $(PATH_BINSUID) ; \
(echo $(MAKEFLAGS) | grep s) > /dev/null ; \
if [ $$? -ne 0 ] ; then \
echo "$(CD) $(PATH_BINSUID)" ; \
echo "$(RM) $(FILE_BINSUID)" ; \
fi ; \
$(RM) $(FILE_BINSUID) ; \
fi)
endif
ifneq ($(FILE_CGI),)
@(if test -d $(PATH_CGI) ; then \
$(CD) $(PATH_CGI) ; \
(echo $(MAKEFLAGS) | grep s) > /dev/null ; \
if [ $$? -ne 0 ] ; then \
echo "$(CD) $(PATH_CGI)" ; \
echo "$(RM) $(FILE_CGI)" ; \
fi ; \
$(RM) $(FILE_CGI) ; \
fi)
endif
ifneq ($(FILE_DOC),)
@(if test -d $(PATH_DOC) ; then \
$(CD) $(PATH_DOC) ; \
(echo $(MAKEFLAGS) | grep s) > /dev/null ; \
if [ $$? -ne 0 ] ; then \
echo "$(CD) $(PATH_DOC)" ; \
echo "$(RM) $(FILE_DOC)" ; \
fi ; \
$(RM) $(FILE_DOC) ; \
fi)
endif
ifneq ($(FILE_ETC),)
@(if test -d $(PATH_ETC) ; then \
$(CD) $(PATH_ETC) ; \
(echo $(MAKEFLAGS) | grep s) > /dev/null ; \
if [ $$? -ne 0 ] ; then \
echo "$(CD) $(PATH_ETC)" ; \
echo "$(RM) $(FILE_ETC)" ; \
fi ; \
$(RM) $(FILE_ETC) ; \
fi)
endif
ifneq ($(FILE_HOME),)
@(if test -d $(PATH_HOME) ; then \
$(CD) $(PATH_HOME) ; \
(echo $(MAKEFLAGS) | grep s) > /dev/null ; \
if [ $$? -ne 0 ] ; then \
echo "$(CD) $(PATH_HOME)" ; \
echo "$(RM) $(FILE_HOME)" ; \
fi ; \
$(RM) $(FILE_HOME) ; \
fi)
endif
ifneq ($(FILE_HOMEBIN),)
@(if test -d $(PATH_HOMEBIN) ; then \
$(CD) $(PATH_HOMEBIN) ; \
(echo $(MAKEFLAGS) | grep s) > /dev/null ; \
if [ $$? -ne 0 ] ; then \
echo "$(CD) $(PATH_HOMEBIN)" ; \
echo "$(RM) $(FILE_HOMEBIN)" ; \
fi ; \
$(RM) $(FILE_HOMEBIN) ; \
fi)
endif
ifneq ($(FILE_LIB),)
@(if test -d $(PATH_LIB) ; then \
$(CD) $(PATH_LIB) ; \
(echo $(MAKEFLAGS) | grep s) > /dev/null ; \
if [ $$? -ne 0 ] ; then \
echo "$(CD) $(PATH_LIB)" ; \
echo "$(RM) $(FILE_LIB)" ; \
fi ; \
$(RM) $(FILE_LIB) ; \
fi)
endif
ifneq ($(FILE_HOMELIB),)
@(if test -d $(PATH_HOMELIB) ; then \
$(CD) $(PATH_HOMELIB) ; \
(echo $(MAKEFLAGS) | grep s) > /dev/null ; \
if [ $$? -ne 0 ] ; then \
echo "$(CD) $(PATH_HOMELIB)" ; \
echo "$(RM) $(FILE_HOMELIB)" ; \
fi ; \
$(RM) $(FILE_HOMELIB) ; \
fi)
endif
ifneq ($(FILE_INCLUDE),)
@(if test -d $(PATH_INCLUDE) ; then \
$(CD) $(PATH_INCLUDE) ; \
(echo $(MAKEFLAGS) | grep s) > /dev/null ; \
if [ $$? -ne 0 ] ; then \
echo "$(CD) $(PATH_INCLUDE)" ; \
echo "$(RM) $(FILE_INCLUDE)" ; \
fi ; \
$(RM) $(FILE_INCLUDE) ; \
fi)
endif
ifneq ($(FILE_MAN),)
@(if test -d $(PATH_MAN) ; then \
$(CD) $(PATH_MAN) ; \
(echo $(MAKEFLAGS) | grep s) > /dev/null ; \
if [ $$? -ne 0 ] ; then \
echo "$(CD) $(PATH_MAN)" ; \
echo "$(RM) $(FILE_MAN)" ; \
fi ; \
$(RM) $(FILE_MAN) ; \
fi)
endif
ifneq ($(FILE_WEBCONF),)
@(if test -d $(PATH_WEBCONF) ; then \
$(CD) $(PATH_WEBCONF) ; \
(echo $(MAKEFLAGS) | grep s) > /dev/null ; \
if [ $$? -ne 0 ] ; then \
echo "$(CD) $(PATH_WEBCONF)" ; \
echo "$(RM) $(FILE_WEBCONF)" ; \
fi ; \
$(RM) $(FILE_WEBCONF) ; \
fi)
endif
ifneq ($(FILE_WEBCONFSSL),)
@(if test -d $(PATH_WEBCONFSSL) ; then \
$(CD) $(PATH_WEBCONFSSL) ; \
(echo $(MAKEFLAGS) | grep s) > /dev/null ; \
if [ $$? -ne 0 ] ; then \
echo "$(CD) $(PATH_WEBCONFSSL)" ; \
echo "$(RM) $(FILE_WEBCONFSSL)" ; \
fi ; \
$(RM) $(FILE_WEBCONFSSL) ; \
fi)
endif
ifneq ($(FILE_HTML),)
@(if test -d $(PATH_HTML) ; then \
$(CD) $(PATH_HTML) ; \
(echo $(MAKEFLAGS) | grep s) > /dev/null ; \
if [ $$? -ne 0 ] ; then \
echo "$(CD) $(PATH_HTML)" ; \
echo "$(RM) $(FILE_HTML)" ; \
fi ; \
$(RM) $(FILE_HTML) ; \
fi)
endif
ifneq ($(FILE_WEBICONS),)
@(if test -d $(PATH_WEBICONS) ; then \
$(CD) $(PATH_WEBICONS) ; \
(echo $(MAKEFLAGS) | grep s) > /dev/null ; \
if [ $$? -ne 0 ] ; then \
echo "$(CD) $(PATH_WEBICONS)" ; \
echo "$(RM) $(FILE_WEBICONS)" ; \
fi ; \
$(RM) $(FILE_WEBICONS) ; \
fi)
endif
$(MAKE) post_uninstall
# "distrib" Rule
distrib:
$(MAKE) clean
$(MKDIR) $(TMP_DIR)/$(PROG_VERSION_NAME)
$(TAR) cf - . | $(TAR) xvpf - -C $(TMP_DIR)/$(PROG_VERSION_NAME)
$(TAR) cvf - -C $(TMP_DIR) --exclude CVS $(PROG_VERSION_NAME) | $(GZIP) -9 >$(PROG_VERSION_NAME).src.tgz
$(TAR) cvf - -C $(TMP_DIR) --exclude CVS $(PROG_VERSION_NAME) | $(BZIP2) -9 >$(PROG_VERSION_NAME).src.tbz2
$(MV) $(TMP_DIR)/$(PROG_VERSION_NAME) .
$(ZIP) -r -m -9 $(PROG_VERSION_NAME).src.zip $(PROG_VERSION_NAME) -x \*/CVS/\*
$(RM) -r $(PROG_VERSION_NAME)

92
Makefile.var Normal file
View File

@@ -0,0 +1,92 @@
# $RCSfile: Makefile.var,v $
# $Revision: 1.1 $
# $Name: $
# $Date: 2005/01/24 23:24:30 $
# $Author: agibert $
#------------------------------------------------------------------------------
# Variable Makefile
#------------------------------------------------------------------------------
PROG_NAME=libshmem
PROG_TAG=$Name: $
ifeq ($(words $(PROG_TAG)),2)
PROG_VERSION_NAME=$(subst _,.,$(word 2, $(PROG_TAG)))
else
PROG_VERSION_NAME=$(PROG_NAME)
endif
CC=/usr/bin/gcc
AR=/usr/bin/ar
CD=cd
MKDIR=/bin/mkdir -p
RM=/bin/rm -f
MV=/bin/mv
TAR=tar
GZIP=gzip
BZIP2=bzip2
ZIP=zip
PATH_WEB=$(addprefix /var/httpd/, $(PROG_NAME))
INSTALLBIN=/usr/bin/install -m 755
INSTALLBINSUID=/usr/bin/install -m 4755
INSTALLCGI=/usr/bin/install -m 555
INSTALLDOC=/usr/bin/install -m 444
INSTALLETC=/usr/bin/install -m 600
INSTALLHOME=/usr/bin/install -m 400
INSTALLHOMEBIN=/usr/bin/install -m 750
INSTALLLIB=/usr/bin/install -m 755
INSTALLHOMELIB=/usr/bin/install -m 755
INSTALLINCLUDE=/usr/bin/install -m 644
INSTALLMAN=/usr/bin/install -m 644
INSTALLWEBCONF=/usr/bin/install -m 644
INSTALLWEBCONFSSL=/usr/bin/install -m 644
INSTALLHTML=/usr/bin/install -m 444
INSTALLWEBICONS=/usr/bin/install -m 444
ifeq ($(ROOT),)
HOME_DIR := /
else
HOME_DIR := $(ROOT)
endif
PATH_BIN := $(addprefix $(HOME_DIR),/usr/bin)
PATH_BINSUID := $(PATH_BIN)
PATH_CGI := $(addprefix $(HOME_DIR),$(addprefix $(PATH_WEB),/cgi-bin))
PATH_DOC := $(addprefix $(HOME_DIR),$(addprefix /usr/share/doc/,$(PROG_VERSION_NAME)))
PATH_ETC := $(addprefix $(HOME_DIR),$(addprefix /etc/,$(MODULE)))
PATH_HOME := $(addprefix $(HOME_DIR),$(addprefix $(addprefix /var/lib/, $(PROG_NAME)), $(MODULE)))
PATH_HOMEBIN := $(addprefix $(HOME_DIR), $(addprefix $(addprefix /var/lib/, $(PROG_NAME)), /bin))
PATH_LIB := $(addprefix $(HOME_DIR),/usr/lib)
PATH_HOMELIB := $(addprefix $(HOME_DIR), $(addprefix $(addprefix /var/lib/, $(PROG_NAME)), /lib))
PATH_INCLUDE := $(addprefix $(HOME_DIR),/usr/include)
PATH_MAN := $(addprefix $(HOME_DIR),/usr/share/man)
PATH_WEBCONF := $(addprefix $(HOME_DIR),/etc/httpd/conf/vhosts)
PATH_WEBCONFSSL := $(addprefix $(HOME_DIR),/etc/httpd/conf/ssl)
PATH_HTML := $(addprefix $(HOME_DIR),$(addprefix $(addprefix $(PATH_WEB),/html/),$(MODULE)))
PATH_WEBICONS := $(addprefix $(HOME_DIR),$(addprefix $(PATH_WEB),/icons))
PATH_LOG := $(addprefix $(HOME_DIR),/var/log)
TMP_DIR=/tmp
CFLAGS=
ifeq ($(DEBUG), YES)
CFLAGS += -g -D_DEBUG
endif
ifeq ($(DEBUG), Y)
CFLAGS += -g -D_DEBUG
endif
ifeq ($(OPTIM), YES)
CFLAGS += -O3
endif
ifeq ($(OPTIM), Y)
CFLAGS += -O3
endif

10
ReadMe.txt
View File

@@ -1,14 +1,14 @@
# $RCSfile: ReadMe.txt,v $
# $Revision: 1.1 $
# $Revision: 2.0 $
# $Name: $
# $Date: 2005/01/24 22:38:02 $
# $Date: 2005/01/24 23:58:23 $
# $Author: agibert $
Welcome to LibShMem 1.0.x !
Welcome to LibShMem 2.0.x !
@@ -18,9 +18,9 @@ This release of LibNode supports the following OS:
The support of LibVer is not optional.
The support of LibVer is now optional (To enable it, use: make _LIBVER_SUPPORT=1 all).
LibShMem support LibNode 1.0.x and LibDataStr 1.0.x !
LibShMem support LibNode 2.1.x and LibDataStr 2.0.x (Not yet released) !

13
ReleaseNotes.txt
View File

@@ -1,13 +1,22 @@
# $RCSfile: ReleaseNotes.txt,v $
# $Revision: 1.1 $
# $Revision: 2.0 $
# $Name: $
# $Date: 2005/01/24 22:38:02 $
# $Date: 2005/01/24 23:58:23 $
# $Author: agibert $
------------------------------------------------------------------------------------------------------------------------------------
LibShMem V 2.0.0 - A. Gibert - xx/02/05
------------------------------------------------------------------------------------------------------------------------------------
All: This new LibShMem branch (2.0.x) support the new LibShMem branch (2.1.x),
LibShMem: ...
------------------------------------------------------------------------------------------------------------------------------------
LibShMem V 1.0.0 - S. Mas / A. Gibert - 28/07/00
------------------------------------------------------------------------------------------------------------------------------------

8
ToDo.txt
View File

@@ -1,13 +1,15 @@
# $RCSfile: ToDo.txt,v $
# $Revision: 1.1 $
# $Revision: 2.0 $
# $Name: $
# $Date: 2005/01/24 22:38:02 $
# $Date: 2005/01/24 23:58:23 $
# $Author: agibert $
- Add LibNode 2.x.x support !
- Code cleanup,
- Add a demo program (a la nddemo0),
- Add a bench program (a la ndbench),
- New English documentation (man/tex),
- Improve API consitency.

54
demo/Makefile Normal file
View File

@@ -0,0 +1,54 @@
SRC := smdemo0.c
TARGETS := smdemo0 smdemo0-c smdemo0-static smdemo0-static-c
FILE_BIN := smdemo0 smdemo0-c smdemo0-static smdemo0-static-c
FILE_LIB := smdemo0.dat
include ../Makefile.var
include ../Makefile.rule
DEP_STATIC += ../lib/libnode.a
DEP_DYNAMIC += ../lib/libnode.so
INCLUDE += -I . -I ../include
LIBDIR += -L . -L ../lib
LIB_STATIC += ../lib/libnode.a -ldl
LIB_DYNAMIC += -lnode -ldl
CFLAGS += -rdynamic
ifdef _LIBVER_SUPPORT
DEP_STATIC += ../../libver/ver.h ../../libver/libver.a
DEP_DYNAMIC += ../../libver/ver.h ../../libver/libver.so
INCLUDE += -I ../../libver/lib
LIBDIR += -L ../../libver/lib
ifeq ($(OSTYPE),linux-gnu)
LIB_STATIC += ../../libver/lib/libver.a
LIB_DYNAMIC += -lver
else
LIB_STATIC += ../../libver/lib/libver.a
LIB_DYNAMIC += -lver
endif
CFLAGS += -D_LIBVER_SUPPORT
endif
ND_CHECK_FLAGS = -DND_MODE=0
ND_NOCHECK_FLAGS = -DND_MODE=1
smdemo0: smdemo0.c $(DEP_DYNAMIC)
$(CC) -o $@ $(CFLAGS) $(ND_NOCHECK_FLAGS) $(INCLUDE) $(LIBDIR) $(LIB_DYNAMIC) $<
smdemo0-c: smdemo0.c $(DEP_DYNAMIC)
$(CC) -o $@ $(CFLAGS) $(ND_CHECK_FLAGS) $(INCLUDE) $(LIBDIR) $(LIB_DYNAMIC) $<
smdemo0-static: smdemo0.c $(DEP_STATIC)
$(CC) -o $@ $(CFLAGS) $(ND_NOCHECK_FLAGS) $(INCLUDE) $< $(LIB_STATIC)
smdemo0-static-c: smdemo0.c $(DEP_STATIC)
$(CC) -o $@ $(CFLAGS) $(ND_CHECK_FLAGS) $(INCLUDE) $< $(LIB_STATIC)

5
doc/Makefile Normal file
View File

@@ -0,0 +1,5 @@
FILE_DOC := libshmem.doc
FILE_MAN := man3
include ../Makefile.var
include ../Makefile.rule

6
include/Makefile Normal file
View File

@@ -0,0 +1,6 @@
FILE_INCLUDE := shmem.h
include ../Makefile.var
include ../Makefile.rule

201
include/shmem.h
View File

@@ -1,3 +1,34 @@
/*---------------------------------------------------------------------------------*/
/* $RCSfile: shmem.h,v $ */
/*---------------------------------------------------------------------------------*/
/* $Revision: 2.2 $ */
/* $Name: $ */
/* $Date: 2005/02/23 23:31:06 $ */
/* $Author: agibert $ */
/*---------------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------------*/
/* This file is part of LibShMem */
/* */
/* LibShMem is free software; you can redistribute it and/or modify */
/* it under the terms of the GNU Lesser General Public Licence as published by */
/* the Free Software Foundation; either version 2.1 of the License, or */
/* (at your option) any later version. */
/* */
/* LibShMem is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU Lesser General Public License for more details. */
/* */
/* You should have received a copy of the GNU Lesser General Public License */
/* along with LibShMem; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
/*---------------------------------------------------------------------------------*/
#ifndef _LIBSM
#define _LIBSM
@@ -11,7 +42,7 @@ extern "C" {
/* Code retour des fonctions constituant l'API */
typedef long SMT_Status;
typedef long SMT_Status;
#define SMS_OK NDS_OK /* La fonction s'est correctement exécutée et a produit un résultat */
#define SMS_KO NDS_KO /* La fonction s'est correctement exécutée mais n'a pas produit de résultat */
@@ -28,7 +59,7 @@ typedef long SMT_Status;
#define SM_ERROR(s) ((s) < 0) /* Tous les codes retour négatifs correspondent à des erreurs */
typedef int SMT_Flags;
typedef int SMT_Flags;
#define SMD_UNDEF 0
@@ -59,12 +90,12 @@ typedef int SMT_Flags;
/* Différentes types de configuration d'un heap */
typedef int SMT_Config;
typedef int SMT_Config;
#define SMD_SEGMENT_SIZE 1 /* Définir la taille des segments */
#define SMD_HEAP_LIMIT 2 /* Définir la taille maximale */
#define SMD_AUTO_COMPRESS 3 /* Définir la taille d'un FCR à partir de laquelle
la compression du heap est autmatiquement activée */
la compression du heap est autmatiquement activée */
#define SMD_DEFAULT_COMPRESS 1000 /* si + de 1000 chunks libres, alors compression du heap */
@@ -85,7 +116,7 @@ typedef int SMT_Config;
#define TRUE 1
#endif
char SM_Error_Msg [512];
char SM_Error_Msg [512];
#ifndef SM_MODE
#define SM_MODE 0
@@ -143,70 +174,70 @@ char SM_Error_Msg [512];
/* Structure de la base de heaps */
/*------------------------------------------------------------------------------*/
typedef struct {
int SysMemID; /* ID de la 1ère zone de mémoire partagée de la base */
int DataMemID; /* ID de la 2ème zone de mémoire partagée de la base */
size_t Size; /* Taille de la zone de mémoire partagée */
int SemID; /* ID du sémaphore pour la gestion des verrous */
NDT_Root * MHR; /* Memory Heap Root : racine de la liste de heap */
pid_t Creator; /* ID du processus créateur de la base */
pid_t Writer; /* ID du dernier processus ayant accédé en écriture à la base */
void * Free; /* Pointeur sur la première zone libre de la base */
void * Attach; /* Adresse du dernier attachement */
size_t Segment_Size; /* Taille par défaut des segments qui composeront les heaps */
} SMT_Base;
typedef struct {
int SysMemId; /* Id de la 1ère zone de mémoire partagée de la base */
int DataMemId; /* Id de la 2ème zone de mémoire partagée de la base */
size_t Size; /* Taille de la zone de mémoire partagée */
int SemId; /* Id du sémaphore pour la gestion des verrous */
NDT_Root * MHR; /* Memory Heap Root : racine de la liste de heap */
pid_t Creator; /* Id du processus créateur de la base */
pid_t Writer; /* Id du dernier processus ayant accédé en écriture à la base */
void * Free; /* Pointeur sur la première zone libre de la base */
void * Attach; /* Adresse du dernier attachement */
size_t Segment_Size; /* Taille par défaut des segments qui composeront les heaps */
} SMT_Base;
/* Référence sur la base de heaps */
SMT_Base * SM_Base;
SMT_Base * SM_Base;
/*------------------------------------------------------------------------------*/
/* Structure d'un MHH (Memory Heap Header) */
/* Rappel : un MHH est une valeur attachée à un MHN (Memory Heap Node) */
/*------------------------------------------------------------------------------*/
typedef struct {
char Name [256]; /* Nom du heap */
int SemID; /* ID du sémaphore pour la gestion des verrous */
NDT_Root * DSR; /* Data Segment Root */
NDT_Root * ACR; /* Allocated Chunks Root */
NDT_Root * FCR; /* Free Chunks Root */
pid_t Writer; /* ID du processus ayant accédé en dernier au MHH en écriture */
int State; /* Etat d'un heap (valide, non validé ou corrompu) */
size_t Segment_Size; /* Taille des segments de mémoire composant le heap */
size_t Limit_Size; /* Taille limite du heap (par défaut : pas de limite) */
int Auto_Compress; /* Nombre de chunks libres à partir duquel le heap est automatiquement compressé */
} SMT_MHH;
typedef struct {
char Name [256]; /* Nom du heap */
int SemId; /* Id du sémaphore pour la gestion des verrous */
NDT_Root * DSR; /* Data Segment Root */
NDT_Root * ACR; /* Allocated Chunks Root */
NDT_Root * FCR; /* Free Chunks Root */
pid_t Writer; /* Id du processus ayant accédé en dernier au MHH en écriture */
int State; /* Etat d'un heap (valide, non validé ou corrompu) */
size_t Segment_Size; /* Taille des segments de mémoire composant le heap */
size_t Limit_Size; /* Taille limite du heap (par défaut : pas de limite) */
int Auto_Compress; /* Nombre de chunks libres à partir duquel le heap est automatiquement compressé */
} SMT_MHH;
/* Heap ouvert */
typedef struct {
char * Name;
SMT_MHH * MHH;
SMT_Flags Lock_Mode; /* Mode dans lequel le heap est verrouillé */
int Nb_Seg; /* Nombre de segments du heap lors de son ouverture */
} SMT_Heap;
typedef struct {
char * Name;
SMT_MHH * MHH;
SMT_Flags Lock_Mode; /* Mode dans lequel le heap est verrouillé */
int Nb_Seg; /* Nombre de segments du heap lors de son ouverture */
} SMT_Heap;
/*------------------------------------------------------------------------------*/
/* Structure d'un DSH (Data Segment Header) */
/* Rappel : un DSH est une valeur attachée à un DSN (noeud de DSR) */
/*------------------------------------------------------------------------------*/
typedef struct {
int MemID; /* ID de la zone de mémoire partagée */
size_t Size; /* Taille de la zone de mémoire partagée */
void * Start; /* Adresse de début de la zone de mémoire partagée */
} SMT_DSH;
typedef struct {
int MemId; /* Id de la zone de mémoire partagée */
size_t Size; /* Taille de la zone de mémoire partagée */
void * Start; /* Adresse de début de la zone de mémoire partagée */
} SMT_DSH;
/*------------------------------------------------------------------------------*/
/* Structure d'un chunk */
/* Rappel : un chunk est la valeur attachée à un noeud de ACR ou FCR */
/*------------------------------------------------------------------------------*/
typedef struct {
size_t Size; /* Taille allouée au chunk */
void * Data; /* Adresse de la zone de données du chunk */
} SMT_Chunk;
typedef struct {
size_t Size; /* Taille allouée au chunk */
void * Data; /* Adresse de la zone de données du chunk */
} SMT_Chunk;
/*------------------------------------------------------------------------------*/
/* Ouverture d'une instance de la librairie */
@@ -215,68 +246,68 @@ typedef struct {
/* (I) Context : nom du nouveau contexte */
/* (I) Flags : indicateur création/ouverture + mode d'affichage des erreurs */
/*------------------------------------------------------------------------------*/
SMT_Status SM_Library_Open_I ( int Instance, const char * Context, SMT_Flags Flags );
SMT_Status SM_Library_Open_C ( int Instance, const char * Context, SMT_Flags Flags );
SMT_Status SM_Library_Open_I ( int Instance, const char * Context, SMT_Flags Flags );
SMT_Status SM_Library_Open_C ( int Instance, const char * Context, SMT_Flags Flags );
/*------------------------------------------------------------------------------*/
/* Récupération du numéro de l'instance utilisée */
/*------------------------------------------------------------------------------*/
/* (O) Instance : adresse du numéro de l'instance utilisée */
/*------------------------------------------------------------------------------*/
SMT_Status SM_Library_Instance_Get_I ( int * Instance);
SMT_Status SM_Library_Instance_Get_C ( int * Instance);
SMT_Status SM_Library_Instance_Get_I ( int * Instance);
SMT_Status SM_Library_Instance_Get_C ( int * Instance);
/*------------------------------------------------------------------------------*/
/* Changement de contexte d'utilisation de la librairie */
/*------------------------------------------------------------------------------*/
/* (I) Context : nom du nouveau contexte */
/*------------------------------------------------------------------------------*/
SMT_Status SM_Library_Context_Set_I ( const char * Context );
SMT_Status SM_Library_Context_Set_C ( const char * Context );
SMT_Status SM_Library_Context_Set_I ( const char * Context );
SMT_Status SM_Library_Context_Set_C ( const char * Context );
/*------------------------------------------------------------------------------*/
/* Récupération du nom du contexte utilisé */
/*------------------------------------------------------------------------------*/
/* (O) Context : adresse du nom du contexte utilisé */
/*------------------------------------------------------------------------------*/
SMT_Status SM_Library_Context_Get_I ( char ** Context );
SMT_Status SM_Library_Context_Get_C ( char ** Context );
SMT_Status SM_Library_Context_Get_I ( char ** Context );
SMT_Status SM_Library_Context_Get_C ( char ** Context );
/*------------------------------------------------------------------------------*/
/* Fermeture de l'instance de la librairie */
/*------------------------------------------------------------------------------*/
/* (I) Flags : mode de fermeture (destruction ou fermeture simple) */
/*------------------------------------------------------------------------------*/
SMT_Status SM_Library_Close_I ( SMT_Flags Flags );
SMT_Status SM_Library_Close_C ( SMT_Flags Flags );
SMT_Status SM_Library_Close_I ( SMT_Flags Flags );
SMT_Status SM_Library_Close_C ( SMT_Flags Flags );
/*------------------------------------------------------------------------------*/
/* Affichage des informations de la base de mémoires partagées */
/*------------------------------------------------------------------------------*/
/* (I) Out : pointeur sur le flux de sortie */
/*------------------------------------------------------------------------------*/
SMT_Status SM_Library_Dump_I ( FILE * Out );
SMT_Status SM_Library_Dump_C ( FILE * Out );
SMT_Status SM_Library_Dump_I ( FILE * Out );
SMT_Status SM_Library_Dump_C ( FILE * Out );
/*------------------------------------------------------------------------------*/
/* Libération de tous les verrous (base, heap) */
/*------------------------------------------------------------------------------*/
SMT_Status SM_Library_Unlock_I ( void );
SMT_Status SM_Library_Unlock_C ( void );
SMT_Status SM_Library_Unlock_I ( void );
SMT_Status SM_Library_Unlock_C ( void );
/*------------------------------------------------------------------------------*/
/* Définition de la sortie standard des messages d'erreur de la librairie */
/*------------------------------------------------------------------------------*/
SMT_Status SM_Library_Stderr_Set_I ( FILE * Out );
SMT_Status SM_Library_Stderr_Set_C ( FILE * Out );
SMT_Status SM_Library_Stderr_Set_I ( FILE * Out );
SMT_Status SM_Library_Stderr_Set_C ( FILE * Out );
/*------------------------------------------------------------------------------*/
/* Test d'existence d'un heap */
/*------------------------------------------------------------------------------*/
/* (I) Heap_Name : nom du heap */
/*------------------------------------------------------------------------------*/
SMT_Status SM_Heap_Exist_I ( const char * Heap_Name );
SMT_Status SM_Heap_Exist_C ( const char * Heap_Name );
SMT_Status SM_Heap_Exist_I ( const char * Heap_Name );
SMT_Status SM_Heap_Exist_C ( const char * Heap_Name );
/*------------------------------------------------------------------------------*/
/* Ouverture/création d'un heap */
@@ -287,8 +318,8 @@ SMT_Status SM_Heap_Exist_C ( const char * Heap_Name );
/* (I) Flags : mode d'ouverture du heap */
/* (O) Locked : verrou effectif (TRUE ou FALSE) */
/*------------------------------------------------------------------------------*/
SMT_Status SM_Heap_Open_I ( const char * Heap_Name, SMT_Heap ** Heap, size_t Seg_Size, SMT_Flags Flags, int * Locked );
SMT_Status SM_Heap_Open_C ( const char * Heap_Name, SMT_Heap ** Heap, size_t Seg_Size, SMT_Flags Flags, int * Locked );
SMT_Status SM_Heap_Open_I ( const char * Heap_Name, SMT_Heap ** Heap, size_t Seg_Size, SMT_Flags Flags, int * Locked );
SMT_Status SM_Heap_Open_C ( const char * Heap_Name, SMT_Heap ** Heap, size_t Seg_Size, SMT_Flags Flags, int * Locked );
/*------------------------------------------------------------------------------*/
/* Teste si un heap a déjà été ouvert par le processus courant */
@@ -296,24 +327,24 @@ SMT_Status SM_Heap_Open_C ( const char * Heap_Name, SMT_Heap ** Heap, size_t Seg
/* (I) Heap_Name : nom du heap */
/* (O) Heap : adresse du pointeur sur le heap ouvert */
/*------------------------------------------------------------------------------*/
SMT_Status SM_Heap_IsOpen_I ( const char * Heap_Name, SMT_Heap ** Heap );
SMT_Status SM_Heap_IsOpen_C ( const char * Heap_Name, SMT_Heap ** Heap );
SMT_Status SM_Heap_IsOpen_I ( const char * Heap_Name, SMT_Heap ** Heap );
SMT_Status SM_Heap_IsOpen_C ( const char * Heap_Name, SMT_Heap ** Heap );
/*------------------------------------------------------------------------------*/
/* Fermeture d'un heap */
/*------------------------------------------------------------------------------*/
/* (I) Heap : pointeur sur un heap ouvert */
/*------------------------------------------------------------------------------*/
SMT_Status SM_Heap_Close_I ( SMT_Heap * Heap );
SMT_Status SM_Heap_Close_C ( SMT_Heap * Heap );
SMT_Status SM_Heap_Close_I ( SMT_Heap * Heap );
SMT_Status SM_Heap_Close_C ( SMT_Heap * Heap );
/*------------------------------------------------------------------------------*/
/* Destruction d'un heap */
/*------------------------------------------------------------------------------*/
/* (I) Heap_Name : nom du heap */
/*------------------------------------------------------------------------------*/
SMT_Status SM_Heap_End_I ( const char * Heap_Name );
SMT_Status SM_Heap_End_C ( const char * Heap_Name );
SMT_Status SM_Heap_End_I ( const char * Heap_Name );
SMT_Status SM_Heap_End_C ( const char * Heap_Name );
/*------------------------------------------------------------------------------*/
/* Compression d'un heap */
@@ -321,8 +352,8 @@ SMT_Status SM_Heap_End_C ( const char * Heap_Name );
/* (I) Heap : pointeur sur un heap ouvert */
/* (O) Compress : pointeur sur la taille mémoire gagnée */
/*------------------------------------------------------------------------------*/
SMT_Status SM_Heap_Compress_I ( SMT_Heap * Heap, size_t * Compress );
SMT_Status SM_Heap_Compress_C ( SMT_Heap * Heap, size_t * Compress );
SMT_Status SM_Heap_Compress_I ( SMT_Heap * Heap, size_t * Compress );
SMT_Status SM_Heap_Compress_C ( SMT_Heap * Heap, size_t * Compress );
/*------------------------------------------------------------------------------*/
/* Configuration d'un heap */
@@ -330,8 +361,8 @@ SMT_Status SM_Heap_Compress_C ( SMT_Heap * Heap, size_t * Compress );
/* (I) Heap : pointeur sur un heap ouvert */
/* (I) Tag : type de configuration */
/*------------------------------------------------------------------------------*/
SMT_Status SM_Heap_Config_I ( SMT_Heap * Heap, SMT_Config Tag, ... );
SMT_Status SM_Heap_Config_C ( SMT_Heap * Heap, SMT_Config Tag, ... );
SMT_Status SM_Heap_Config_I ( SMT_Heap * Heap, SMT_Config Tag, ... );
SMT_Status SM_Heap_Config_C ( SMT_Heap * Heap, SMT_Config Tag, ... );
/*------------------------------------------------------------------------------*/
/* Vérification/correction des structures d'un heap : */
@@ -341,8 +372,8 @@ SMT_Status SM_Heap_Config_C ( SMT_Heap * Heap, SMT_Config Tag, ... );
/* (O) Nb_Corrected : pointeur sur le nombre d'erreurs corrigées */
/* (I) Out : pointeur sur le flux de sortie du rapport */
/*------------------------------------------------------------------------------*/
SMT_Status SM_Heap_Check_I ( SMT_Heap * Heap, int * Nb_Detected, int * Nb_Corrected, FILE * Out);
SMT_Status SM_Heap_Check_C ( SMT_Heap * Heap, int * Nb_Detected, int * Nb_Corrected, FILE * Out);
SMT_Status SM_Heap_Check_I ( SMT_Heap * Heap, int * Nb_Detected, int * Nb_Corrected, FILE * Out);
SMT_Status SM_Heap_Check_C ( SMT_Heap * Heap, int * Nb_Detected, int * Nb_Corrected, FILE * Out);
/*------------------------------------------------------------------------------*/
/* Pose d'un verrou sur un heap */
@@ -351,16 +382,16 @@ SMT_Status SM_Heap_Check_C ( SMT_Heap * Heap, int * Nb_Detected, int * Nb_Correc
/* (I) Flags : mode de verrouillage (SMD_READ ou SMD_WRITE) */
/* (O) Locked : verrouillage effectué (TRUE ou FALSE) */
/*------------------------------------------------------------------------------*/
SMT_Status SM_Heap_Lock_I ( SMT_Heap * Heap, SMT_Flags Flags, int * Locked );
SMT_Status SM_Heap_Lock_C ( SMT_Heap * Heap, SMT_Flags Flags, int * Locked );
SMT_Status SM_Heap_Lock_I ( SMT_Heap * Heap, SMT_Flags Flags, int * Locked );
SMT_Status SM_Heap_Lock_C ( SMT_Heap * Heap, SMT_Flags Flags, int * Locked );
/*------------------------------------------------------------------------------*/
/* Libération d'un verrou sur un heap */
/*------------------------------------------------------------------------------*/
/* (I) Heap : pointeur sur un heap ouvert */
/*------------------------------------------------------------------------------*/
SMT_Status SM_Heap_Unlock_I ( SMT_Heap * Heap );
SMT_Status SM_Heap_Unlock_C ( SMT_Heap * Heap );
SMT_Status SM_Heap_Unlock_I ( SMT_Heap * Heap );
SMT_Status SM_Heap_Unlock_C ( SMT_Heap * Heap );
/*------------------------------------------------------------------------------*/
/* Allocation d'un chunk dans un heap */
@@ -369,8 +400,8 @@ SMT_Status SM_Heap_Unlock_C ( SMT_Heap * Heap );
/* (I) Size : taille du chunk */
/* (O) Ptr : pointeur sur la zone de données allouée */
/*------------------------------------------------------------------------------*/
SMT_Status SM_Chunk_Alloc_I ( SMT_Heap * Heap, size_t Alloc_Size, void ** Ptr );
SMT_Status SM_Chunk_Alloc_C ( SMT_Heap * Heap, size_t Alloc_Size, void ** Ptr );
SMT_Status SM_Chunk_Alloc_I ( SMT_Heap * Heap, size_t Alloc_Size, void ** Ptr );
SMT_Status SM_Chunk_Alloc_C ( SMT_Heap * Heap, size_t Alloc_Size, void ** Ptr );
/*------------------------------------------------------------------------------*/
/* Désallocation d'un chunk */
@@ -378,8 +409,8 @@ SMT_Status SM_Chunk_Alloc_C ( SMT_Heap * Heap, size_t Alloc_Size, void ** Ptr );
/* (I) Heap : pointeur sur un heap ouvert */
/* (I) Ptr : adresse de la zone de données du chunk à désallouer */
/*------------------------------------------------------------------------------*/
SMT_Status SM_Chunk_Free_I ( SMT_Heap * Heap, void * Ptr );
SMT_Status SM_Chunk_Free_C ( SMT_Heap * Heap, void * Ptr );
SMT_Status SM_Chunk_Free_I ( SMT_Heap * Heap, void * Ptr );
SMT_Status SM_Chunk_Free_C ( SMT_Heap * Heap, void * Ptr );
#ifdef __cplusplus
}

22
lib/Makefile Normal file
View File

@@ -0,0 +1,22 @@
SRC := libshmem.c
TARGETS := libshmem.a libshmem.so
FILE_LIB := libshmem.a libshmem.so
include ../Makefile.var
include ../Makefile.rule
DEP += libshmem.h ../include/shmem.h ../../libnode/include/node.h Makefile
INCLUDE += -I . -I ../include -I ../../libnode/include
ifdef _LIBVER_SUPPORT
DEP += ../../libver/ver.h
INCLUDE += -I ../../libver/lib
endif
libshmem.o : libshmem.c $(DEP)

3139
lib/libshmem.c
View File

File diff suppressed because it is too large Load Diff

102
lib/libshmem.h
View File

@@ -1,19 +1,59 @@
/*---------------------------------------------------------------------------------*/
/* $RCSfile: libshmem.h,v $ */
/*---------------------------------------------------------------------------------*/
/* $Revision: 2.2 $ */
/* $Name: $ */
/* $Date: 2005/02/23 23:31:06 $ */
/* $Author: agibert $ */
/*---------------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------------*/
/* This file is part of LibShMem */
/* */
/* LibShMem is free software; you can redistribute it and/or modify */
/* it under the terms of the GNU Lesser General Public Licence as published by */
/* the Free Software Foundation; either version 2.1 of the License, or */
/* (at your option) any later version. */
/* */
/* LibShMem is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU Lesser General Public License for more details. */
/* */
/* You should have received a copy of the GNU Lesser General Public License */
/* along with LibShMem; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
/*---------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <stdarg.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <sys/ipc.h>
#include <ver.h>
#include <shmem.h>
/* Compteur d'ouverture de la librairie */
unsigned int SM_Open_Counter = 0;
/* Flux de sortie des messages d'erreur générés par la librairie */
FILE * SM_stderr;
@@ -22,10 +62,16 @@ extern char * strdup (const char *);
#define max(A,B) ((A < B) ? B : A)
/* Limite supérieure d'adressage */
#define MEM_LIMIT 1000000000
//#define SMD_CMD_VALUE_SUM (NDT_Command)65
#define NDD_CMD_VALUE_SUM (NDT_Command)NDD_CMD_USER_TRAVERSE
/* Taille d'un segment = 100 Ko par défaut */
#define K 1024
@@ -34,10 +80,11 @@ extern char * strdup (const char *);
char Info_Msg [256];
/* Etats possibles pour un heap */
#define SMD_STATE_VALID 0
#define SMD_STATE_UNVALIDATED 1
#define SMD_STATE_UNVALIDATED 1
#define SMD_STATE_CORRUPTED 2
/* Référence sur le heap système */
@@ -49,17 +96,17 @@ SMT_Heap * System_Heap;
NDT_Root * Opened_Heap_List;
/*
Taille par défaut des chunks alloués dans le heap système :
Cette taille est fixée à la taille maximale des chunks pouvant
y être alloué (de type NDT_Node, NDT_Root, SMT_MHH ou SMT_DSH)
Taille par défaut des chunks alloués dans le heap système :
Cette taille est fixée à la taille maximale des chunks pouvant
y être alloué (de type NDT_Node, NDT_Root, SMT_MHH ou SMT_DSH)
*/
#define DEFAULT_CHUNK_SIZE max(max(sizeof(NDT_Root), sizeof(NDT_Node)), max(sizeof(SMT_MHH), sizeof(SMT_DSH)))
/*
Nombre de chunk libre minimum avant extension du heap système par un
nouveau segment de données (fixé à 3 car l'ajout d'un nouveau segment
nécessite l'allocation de 2 chunks (un noeud et une entête de segment).
Nombre de chunk libre minimum avant extension du heap système par un
nouveau segment de données (fixé à 3 car l'ajout d'un nouveau segment
nécessite l'allocation de 2 chunks (un noeud et une entête de segment).
*/
#define FREE_CHUNK_LIMIT 3
@@ -76,8 +123,8 @@ char * SM_Context;
#define CONTEXT_ENV_VAR "CONTEXT"
/*
Variable globale permettant d'indiquer que l'on est en train
d'étendre le heap système par ajout d'un nouveau segment.
Variable globale permettant d'indiquer que l'on est en train
d'étendre le heap système par ajout d'un nouveau segment.
*/
unsigned int Adding_Segment = FALSE;
@@ -86,8 +133,8 @@ SMT_Chunk * Tmp_Chunk;
SMT_MHH * Tmp_MHH;
/*
Définition des opérations de verouillage et de déverrouillage
NB : la valeur 1 d'un sémaphore correspond à l'état non verrouillé
Définition des opérations de verouillage et de déverrouillage
NB : la valeur 1 d'un sémaphore correspond à l'état non verrouillé
*/
/* Pose d'un verrou en lecture : 2 opérations : ( -1 puis +2 ) */
@@ -112,30 +159,30 @@ struct sembuf SM_SemOp_TSL [2] = { {0, 0, SEM_UNDO|IPC_NOWAIT}, {0, 2, SEM_UNDO
typedef union semun
{
int val;
struct semid_ds * buf;
unsigned short int * array;
int val;
struct semid_ds * buf;
unsigned short int * array;
} semun;
/*------------------------------------------------------------------------------*/
/* Allocation de mémoire dans la base */
/*------------------------------------------------------------------------------*/
SMT_Status SM_Base_Alloc (size_t, void **, void *);
NDT_Status SM_Base_Alloc( void **, size_t, void *);
/*------------------------------------------------------------------------------*/
/* Désallocation de mémoire dans la base */
/*------------------------------------------------------------------------------*/
SMT_Status SM_Base_Free (void *, void *);
NDT_Status SM_Base_Free( void *, void *);
/*------------------------------------------------------------------------------*/
/* Allocation de mémoire dans le heap système */
/*------------------------------------------------------------------------------*/
SMT_Status SM_System_Alloc (size_t, void **, void *);
NDT_Status SM_System_Alloc( void **, size_t, void *);
/*------------------------------------------------------------------------------*/
/* Désallocation de mémoire dans le heap système */
/*------------------------------------------------------------------------------*/
SMT_Status SM_System_Free (void *, void *);
NDT_Status SM_System_Free( void *, void *);
/*------------------------------------------------------------------------------*/
/* Initialisation de la base */
@@ -170,12 +217,12 @@ SMT_Status SM_Base_Unlock (SMT_Flags);
/*------------------------------------------------------------------------------*/
/* Fonction manager de la liste des heaps ouverts */
/*------------------------------------------------------------------------------*/
NDT_Status SM_Opened_Heap_List_Manager (va_list);
NDT_Status SM_Opened_Heap_List_Manager ( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list);
/*------------------------------------------------------------------------------*/
/* Fonction manager du MHR (Memory Heap Root) */
/*------------------------------------------------------------------------------*/
NDT_Status MHR_Manager (va_list);
NDT_Status MHR_Manager( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list);
/*------------------------------------------------------------------------------*/
/* Destruction d'un MHH (Memory Heap Header) */
@@ -185,7 +232,7 @@ SMT_Status SM_MHH_End (SMT_MHH *);
/*------------------------------------------------------------------------------*/
/* Fonction manager pour un DSR (Data Segment Root) */
/*------------------------------------------------------------------------------*/
NDT_Status SM_DSR_Manager (va_list);
NDT_Status SM_DSR_Manager( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list);
/*------------------------------------------------------------------------------*/
/* Initialisation d'un nouveau segment de données (noeud du DSR) */
@@ -215,12 +262,12 @@ size_t SM_DataSegment_Compress (SMT_DSH *, NDT_Root *);
/*------------------------------------------------------------------------------*/
/* Fonction manager pour un ACR (Allocated Chunk Root) */
/*------------------------------------------------------------------------------*/
NDT_Status SM_ACR_Manager (va_list);
NDT_Status SM_ACR_Manager( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list);
/*------------------------------------------------------------------------------*/
/* Fonction manager pour un FCR (Free Chunk Root) */
/*------------------------------------------------------------------------------*/
NDT_Status SM_FCR_Manager(va_list);
NDT_Status SM_FCR_Manager( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list);
/*------------------------------------------------------------------------------*/
/* Pose d'un verrou sur un heap : */
@@ -247,11 +294,6 @@ SMT_Status SM_Semaphore_Operate (int, struct sembuf *, unsigned int);
/*------------------------------------------------------------------------------*/
char * SM_Lock_Status_Get (const char *, void *);
/*------------------------------------------------------------------------------*/
/* Récupère sous forme explicite la description d'une racine de structure */
/*------------------------------------------------------------------------------*/
char * SM_Root_Description_Get (const char *, NDT_Root *);
/*------------------------------------------------------------------------------*/
/* Routine d'affichage d'un message d'erreur */
/*------------------------------------------------------------------------------*/

62
libshmem.spec Normal file
View File

@@ -0,0 +1,62 @@
Name: libshmem
Version: 2.0.0
%define release_nb 1
Release: %{release_nb}rx3
%define libnode_name %{name}-%{version}-%{release_nb}
%define source %{libnode_name}.src.tgz
Summary: A shared memory pool manager C library
Copyright: GPL/LGPL
Group: Application/Utilitaires
Distribution: Rx3 OpenSource
Vendor: Rx3
Packager: Arnaud G. Gibert <arnaud@rx3.net>
Source: ftp://ftp.rx3.org/pub/%{source}
Url: http://www.rx3.org/dvp/libshmem/download/
BuildRoot: %{_tmppath}/%{libnode_name}-buildroot
AutoReqProv: no
%description
Manages a memory pool in share memory
%files
/usr
%build
rm -rf %{libnode_name}
tar -xzvvf /usr/src/RPM/SOURCES/%{source}
cd %{libnode_name}
make clean
make all
%install
cd %{libnode_name}
make install ROOT=$RPM_BUILD_ROOT
%clean
rm -rf %{libnode_name}
rm -rf $RPM_BUILD_ROOT
%changelog
* Tue Jan 25 2005 Arnaud G. Gibert <arnaud@rx3.net> 2.0.0-1rx3
- Initial release of this spec file.

52
util/Makefile Normal file
View File

@@ -0,0 +1,52 @@
SRC := smadmin.c
TARGETS := smadmin smadmin-c smadmin-static smadmin-static-c
FILE_BIN := smadmin smadmin-c smadmin-static smadmin-static-c
include ../Makefile.var
include ../Makefile.rule
DEP_STATIC += ../lib/libshmem.a ../../libnode/lib/libnode.a
DEP_DYNAMIC += ../lib/libshmem.so ../../libnode/lib/libnode.so
INCLUDE += -I . -I ../include -I ../../libnode/include
LIBDIR += -L . -L ../lib -L ../../libnode/lib
LIB_STATIC += ../lib/libshmem.a ../../libnode/lib/libnode.a -ldl
LIB_DYNAMIC += -lshmem -lnode -ldl
CFLAGS += -rdynamic
ifdef _LIBVER_SUPPORT
DEP_STATIC += ../../libver/ver.h ../../libver/libver.a
DEP_DYNAMIC += ../../libver/ver.h ../../libver/libver.so
INCLUDE += -I ../../libver/lib
LIBDIR += -L ../../libver/lib
ifeq ($(OSTYPE),linux-gnu)
LIB_STATIC += ../../libver/lib/libver.a
LIB_DYNAMIC += -lver
else
LIB_STATIC += ../../libver/lib/libver.a
LIB_DYNAMIC += -lver
endif
CFLAGS += -D_LIBVER_SUPPORT
endif
ND_CHECK_FLAGS = -DSM_MODE=0
ND_NOCHECK_FLAGS = -DSM_MODE=1
smadmin: smadmin.c $(DEP_DYNAMIC)
$(CC) -o $@ $(CFLAGS) $(ND_NOCHECK_FLAGS) $(INCLUDE) $(LIBDIR) $(LIB_DYNAMIC) $<
smadmin-c: smadmin.c $(DEP_DYNAMIC)
$(CC) -o $@ $(CFLAGS) $(ND_CHECK_FLAGS) $(INCLUDE) $(LIBDIR) $(LIB_DYNAMIC) $<
smadmin-static: smadmin.c $(DEP_STATIC)
$(CC) -o $@ $(CFLAGS) $(ND_NOCHECK_FLAGS) $(INCLUDE) $< $(LIB_STATIC)
smadmin-static-c: smadmin.c $(DEP_STATIC)
$(CC) -o $@ $(CFLAGS) $(ND_CHECK_FLAGS) $(INCLUDE) $< $(LIB_STATIC)

18
util/smadmin.c
View File

@@ -6,7 +6,7 @@
#define SM_MODE 0 /* Utilisation des API sécurisés */
#include <shmem.h>
VER_INFO_EXPORT (smadmin, "$Revision: 1.1 $", "$Name: $", __FILE__, "$Author: smas $")
//VER_INFO_EXPORT (smadmin, "$Revision: 2.1 $", "$Name: $", __FILE__, "$Author: agibert $")
#define USAGE "Usage : %s [ --help | --version [-v] | --create | --destroy ]\n"
@@ -56,13 +56,13 @@ int main (int argc, char ** argv)
fprintf (stderr, USAGE, argv[0]);
return -1;
}
else if (!strcmp (argv[1], "--version"))
/* else if (!strcmp (argv[1], "--version"))
{
if (argc >= 3 && !strcmp (argv[2], "-v"))
return VER_Object_Print (stdout, VERD_VERBOSE);
else
return VER_Object_Print (stdout, VERD_MINIMAL);
}
} */
else if (!strcmp (argv[1], "--create"))
{
if (SM_Library_Open (0, NULL, SMD_CREATE | SMD_DEBUG_ALL) != SMS_OK)
@@ -261,8 +261,8 @@ int main (int argc, char ** argv)
gets (name);
if (SM_Heap_Open (name, &Heap, 0, SMD_OPEN | SMD_READ, &Locked) == SMS_OK)
{
ND_DataStruct_Info_Print (Heap->MHH->DSR, stdout);
ND_DataStruct_Print (Heap->MHH->DSR, stdout);
ND_DataStruct_Info_Print( stdout, Heap->MHH->DSR, NDD_RECURSIVE_MODE_PARENT_CHILD, 0, 0);
ND_DataStruct_Value_Print( stdout, Heap->MHH->DSR, NDD_RECURSIVE_MODE_PARENT_CHILD, 0, 0);
if (Locked == TRUE) SM_Heap_Unlock (Heap);
}
break;
@@ -272,8 +272,8 @@ int main (int argc, char ** argv)
gets (name);
if (SM_Heap_Open (name, &Heap, 0, SMD_OPEN | SMD_READ, &Locked) == SMS_OK)
{
ND_DataStruct_Info_Print (Heap->MHH->ACR, stdout);
ND_DataStruct_Print (Heap->MHH->ACR, stdout);
ND_DataStruct_Info_Print( stdout, Heap->MHH->ACR, NDD_RECURSIVE_MODE_PARENT_CHILD, 0, 0);
ND_DataStruct_Value_Print( stdout, Heap->MHH->ACR, NDD_RECURSIVE_MODE_PARENT_CHILD, 0, 0);
if (Locked == TRUE) SM_Heap_Unlock (Heap);
}
break;
@@ -283,8 +283,8 @@ int main (int argc, char ** argv)
gets (name);
if (SM_Heap_Open (name, &Heap, 0, SMD_OPEN | SMD_READ, &Locked) == SMS_OK)
{
ND_DataStruct_Info_Print (Heap->MHH->FCR, stdout);
ND_DataStruct_Print (Heap->MHH->FCR, stdout);
ND_DataStruct_Info_Print( stdout, Heap->MHH->FCR, NDD_RECURSIVE_MODE_PARENT_CHILD, 0, 0);
ND_DataStruct_Value_Print( stdout, Heap->MHH->FCR, NDD_RECURSIVE_MODE_PARENT_CHILD, 0, 0);
if (Locked == TRUE) SM_Heap_Unlock (Heap);
}
break;