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:0e2be6c11b9e792d68e8a9fa6723cbad9f1d120c
Branches Tags
Rx3:master Rx3:libshmem-2.1
Rx3:libshmem-2.1.0 Rx3:libshmem-1_0_0-1

17 Commits
libshmem-1 ... 0e2be6c11b

Author SHA1 Message Date
agibert
0e2be6c11b Add HP-UX 11 support, 
Add SMDemo0 demo,
Improve Managers structure.
 2005-06-27 00:17:36 +00:00
agibert
998062740e Add a prelimary fix in SM_Heap_Lock() about new segments mapping in System Heap, 
Warning: This is broken and needs debugging...
 2005-06-26 23:40:14 +00:00
agibert
7fb191ce32 Add smdem0.c, smdemo0_snd.c and smdemo0_snd.c sources. 2005-06-26 23:20:32 +00:00
agibert
168b1818c6 Initial release. 2005-06-26 23:16:38 +00:00
agibert
736a074b28 Add Compress_Nb counter in SMT_MHH structure. 2005-06-26 23:07:40 +00:00
agibert
a71fd35b9e Replace atoi() into atol(). 2005-06-26 23:06:22 +00:00
agibert
193e13bc58 Add demo in sub-dirs. 2005-06-26 23:04:11 +00:00
agibert
c89aef3694 Remove SM_DataSegment_Init() and SM_DataSegment_End() functions. 2005-06-26 23:02:35 +00:00
agibert
d956060f49 Move some initialisation code from SM_Heap_Open() to Value_Alloc methode of SM_MHR_Manager(), 
Move all the code of SM_DataSegment_Init() function to Value_Alloc methode of SM_DSR_Manager(),
Move all the code of SM_DataSegment_End() function to Value_Free methode of SM_DSR_Manager(),
Remove SM_DataSegment_Init() and SM_DataSegment_End() functions,
Thanks to H. Moussaid for these preceding changes,
Add HP-UX support,
Add support for Compress_Nb counter in SMT_MHH,
Misc debugging,
Fix some printouts...
 2005-06-26 22:50:49 +00:00
agibert
1f4d73bc70 Replace gets() calls into fgets(), 2005-02-23 23:34:48 +00:00
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
19 changed files with 4506 additions and 1298 deletions
Expand all files Collapse all files

25
Makefile Normal file
View File

@@ -0,0 +1,25 @@
# $RCSfile: Makefile,v $
# $Revision: 1.2 $
# $Name: $
# $Date: 2005/06/26 23:04:11 $
# $Author: agibert $
#------------------------------------------------------------------------------
# Main Makefile
#------------------------------------------------------------------------------
SUBDIRS := include lib util demo 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) !

15
ReleaseNotes.txt
View File

@@ -1,13 +1,24 @@
# $RCSfile: ReleaseNotes.txt,v $
# $Revision: 1.1 $
# $Revision: 2.1 $
# $Name: $
# $Date: 2005/01/24 22:38:02 $
# $Date: 2005/06/27 00:17:36 $
# $Author: agibert $
------------------------------------------------------------------------------------------------------------------------------------
LibShMem V 2.0.0 - A. Gibert - xx/06/05
------------------------------------------------------------------------------------------------------------------------------------
All: This new LibShMem branch (2.0.x) support the new LibNode branch (2.1.x),
LibShMem: Add HP-UX 11 support,
Improve Manager structure in a more LibNode 2 way,
SMDemo0: Add a new demo !
------------------------------------------------------------------------------------------------------------------------------------
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.

81
demo/Makefile Normal file
View File

@@ -0,0 +1,81 @@
SRC := smdemo0.c smdemo0_snd.c smdemo0_rcv.c
TARGETS := smdemo0 smdemo0-c smdemo0-static smdemo0-static-c \
smdemo0_snd smdemo0_snd-c smdemo0_snd-static smdemo0_snd-static-c \
smdemo0_rcv smdemo0_rcv-c smdemo0_rcv-static smdemo0_rcv-static-c
FILE_BIN := smdemo0 smdemo0-c smdemo0-static smdemo0-static-c \
smdemo0_snd smdemo0_snd-c smdemo0_snd-static smdemo0_snd-static-c \
smdemo0_rcv smdemo0_rcv-c smdemo0_rcv-static smdemo0_rcv-static-c
FILE_LIB := smdemo0.dat
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 = -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)
smdemo0_snd: smdemo0_snd.c $(DEP_DYNAMIC)
$(CC) -o $@ $(CFLAGS) $(ND_NOCHECK_FLAGS) $(INCLUDE) $(LIBDIR) $(LIB_DYNAMIC) $<
smdemo0_snd-c: smdemo0_snd.c $(DEP_DYNAMIC)
$(CC) -o $@ $(CFLAGS) $(ND_CHECK_FLAGS) $(INCLUDE) $(LIBDIR) $(LIB_DYNAMIC) $<
smdemo0_snd-static: smdemo0_snd.c $(DEP_STATIC)
$(CC) -o $@ $(CFLAGS) $(ND_NOCHECK_FLAGS) $(INCLUDE) $< $(LIB_STATIC)
smdemo0_snd-static-c: smdemo0_snd.c $(DEP_STATIC)
$(CC) -o $@ $(CFLAGS) $(ND_CHECK_FLAGS) $(INCLUDE) $< $(LIB_STATIC)
smdemo0_rcv: smdemo0_rcv.c $(DEP_DYNAMIC)
$(CC) -o $@ $(CFLAGS) $(ND_NOCHECK_FLAGS) $(INCLUDE) $(LIBDIR) $(LIB_DYNAMIC) $<
smdemo0_rcv-c: smdemo0_rcv.c $(DEP_DYNAMIC)
$(CC) -o $@ $(CFLAGS) $(ND_CHECK_FLAGS) $(INCLUDE) $(LIBDIR) $(LIB_DYNAMIC) $<
smdemo0_rcv-static: smdemo0_rcv.c $(DEP_STATIC)
$(CC) -o $@ $(CFLAGS) $(ND_NOCHECK_FLAGS) $(INCLUDE) $< $(LIB_STATIC)
smdemo0_rcv-static-c: smdemo0_rcv.c $(DEP_STATIC)
$(CC) -o $@ $(CFLAGS) $(ND_CHECK_FLAGS) $(INCLUDE) $< $(LIB_STATIC)

380
demo/smdemo0.c Normal file
View File

@@ -0,0 +1,380 @@
/*---------------------------------------------------------------------------------*/
/* $RCSfile: smdemo0.c,v $ */
/*---------------------------------------------------------------------------------*/
/* $Revision: 1.1 $ */
/* $Name: $ */
/* $Date: 2005/06/26 23:16:38 $ */
/* $Author: agibert $ */
/*---------------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------------*/
/* This file is a program test 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 <string.h>
#include <stdarg.h>
#include <unistd.h>
#include <errno.h>
#include <node.h>
#ifndef SM_MODE
# define SM_MODE 0 /* Utilisation des API sécurisés */
#endif
#include <shmem.h>
#define LOG_ERROR 10
#define LOG_WARNING 20
#define LOG_INFO 30
#define LOG_TRACE 40
#define FATHER_ID 0
#define SON_SND_ID 1
#define SON_SND_NAME "snd"
#define SON_RCV_ID 2
#define SON_RCV_NAME "rcv"
#define INST_MAX 256
void Log_Print( int, int, int, int, char *, ...);
int Do_Fork_Exec( char **, int, int, int, int *, int);
void Make_Son_Cmd_Name( char *, char *, char *);
int main( int , char **);
void Log_Print( int Log_Level, int Verbose_Level, int Proc_Id, int Inst_Id, char *Format_Str, ...)
{
va_list args;
char *prompt[] = { "father", "snd", "rcv"};
int fmt_size = 255;
char fmt[ fmt_size + 1];
if( Log_Level <= Verbose_Level)
{
va_start( args, Format_Str);
if( Proc_Id == FATHER_ID)
{
snprintf( fmt, fmt_size, "%s: %s", prompt[Proc_Id], Format_Str);
}
else
{
snprintf( fmt, fmt_size, "%s%02d : %s", prompt[Proc_Id], Inst_Id, Format_Str);
}
vfprintf( stderr, fmt, args);
fflush( stderr);
va_end( args);
}
}
int Do_Fork_Exec( char **ArgV_Tab, int Proc_Id, int Inst_Id, int Dir, int Pipe_Desc[2], int Verbose_Level)
{
pid_t pid;
int rc;
char cmd[1024] = "";
int i;
for( i = 0; ArgV_Tab[i] != NULL; i++)
{
if( i > 0)
{
strcat( cmd, " ");
}
strcat( cmd, ArgV_Tab[i]);
}
Log_Print( LOG_TRACE, Verbose_Level, FATHER_ID, 0, "Forking Inst_Id: (%d) Dir: (%d) Cmd: [%s]...\n", Inst_Id, Dir, cmd);
switch( pid = fork())
{
case 0:
{
Log_Print( LOG_INFO, Verbose_Level, Proc_Id, Inst_Id, "PId: (%d) PPId: (%d) Exec_File: [%s]\n", getpid(), getppid(), ArgV_Tab[0]);
if( ( rc = close( Pipe_Desc[ 1 - Dir])) == -1)
{
Log_Print( LOG_ERROR, Verbose_Level, Proc_Id, Inst_Id, "close() failed: (%d) !\n", errno);
exit( -1);
}
if( ( rc = dup2( Pipe_Desc[ Dir], Dir)) == -1)
{
Log_Print( LOG_ERROR, Verbose_Level, Proc_Id, Inst_Id, "dup2() failed: (%d) !\n", errno);
exit( -1);
}
if( ( rc = execv( ArgV_Tab[0], ArgV_Tab)) == -1)
{
Log_Print( LOG_ERROR, Verbose_Level, Proc_Id, Inst_Id, "execv() failed: (%d) !\n", errno);
exit( -1);
}
exit(-1);
}
case -1:
{
Log_Print( LOG_ERROR, Verbose_Level, FATHER_ID, Inst_Id, "fork() failed: (%d) !\n", errno);
return( -1);
}
default:
{
Log_Print( LOG_INFO, Verbose_Level, FATHER_ID, Inst_Id, "PId: (%d) Son_PId: (%d)\n", getpid(), pid);
return( 0);
}
}
}
void Make_Son_Cmd_Name( char *Son_Cmd_Name, char *Father_Cmd_Name, char *Son_Name)
{
char *ptr;
if( ( ptr = strstr( Father_Cmd_Name, "-")) == NULL)
{
ptr = Father_Cmd_Name + strlen( Father_Cmd_Name);
}
strncpy( Son_Cmd_Name, Father_Cmd_Name, ( ptr - Father_Cmd_Name));
Son_Cmd_Name[ ( ptr - Father_Cmd_Name)] = '\0';
strcat( Son_Cmd_Name, "_");
strcat( Son_Cmd_Name, Son_Name);
strcat( Son_Cmd_Name, ptr);
}
int main( int ArgC, char **ArgV)
{
char *Heap_Name;
int Inst_Nb;
int Chunk_Nb;
size_t Chunk_Size;
int Verbose_Level = 30;
SMT_Heap *heap_ptr;
size_t heap_size = 1024;
int locked;
SMT_Status status;
int rc;
int pipe_desc[2];
pid_t pid;
char *ptr;
char *argv_tab[10];
char son_cmd[256];
char inst_id_str[32];
char chunk_nb_str[32];
char chunk_size_str[32];
char verbose_level_str[32];
int inst_id;
short error = 0;
if( ArgC != 6)
{
Log_Print( LOG_ERROR, Verbose_Level, FATHER_ID, 0, "Usage: %s Inst_Nb Heap_Name Chunck_Nb Chunk_Size Verbose_Level\n", ArgV[0]);
exit( -1);
}
else
{
Inst_Nb = atoi( ArgV[1]);
Heap_Name = ArgV[2];
Chunk_Nb = atoi( ArgV[3]);
Chunk_Size = atoi( ArgV[4]);
Verbose_Level = atoi( ArgV[5]);
if( Inst_Nb > INST_MAX)
{
Log_Print( LOG_ERROR, Verbose_Level, FATHER_ID, 0, "Inst_Nb: (%d) > (%d) !\n", Inst_Nb, INST_MAX);
exit( -1);
}
Log_Print( LOG_INFO, Verbose_Level, FATHER_ID, 0, "Inst_Nb: (%d) Heap_Name: [%s] Chunck_Nb: (%d) Chunck_Size: (%d) Verbose_Level: (%d)...\n",
Inst_Nb, Heap_Name, Chunk_Nb, Chunk_Size, Verbose_Level);
}
if( ( status = SM_Library_Open( 0, NULL, ( SMD_OPEN | SMD_DEBUG_ALL))) != SMS_OK)
{
Log_Print( LOG_ERROR, Verbose_Level, FATHER_ID, 0, "Can't open LibShMem (%d) !\n", status);
exit( -1);
}
Log_Print( LOG_TRACE, Verbose_Level, FATHER_ID, 0, "LibShMem opened !\n");
if( ( status = SM_Heap_Open( Heap_Name, &heap_ptr, heap_size, ( SMD_OPEN | SMD_CREATE | SMD_NO_LOCK), &locked)) != SMS_OK)
{
Log_Print( LOG_ERROR, Verbose_Level, FATHER_ID, 0, "Can't create heap (%d) !\n", status);
}
else
{
Log_Print( LOG_TRACE, Verbose_Level, FATHER_ID, 0, "Heap opened !\n");
for( inst_id = 0, error = 0; ( inst_id < Inst_Nb) && ( error == 0); inst_id++)
{
if( pipe( pipe_desc) == -1)
{
Log_Print( LOG_ERROR, Verbose_Level, FATHER_ID, 0, "Con't open pipe (%d) !\n", errno);
error = 1;
}
else
{
argv_tab[0] = son_cmd;
Make_Son_Cmd_Name( argv_tab[0], ArgV[0], SON_SND_NAME);
argv_tab[1] = inst_id_str;
sprintf( argv_tab[1], "%d", inst_id);
argv_tab[2] = Heap_Name;
argv_tab[3] = chunk_nb_str;
sprintf( argv_tab[3], "%d", Chunk_Nb);
argv_tab[4] = chunk_size_str;
sprintf( argv_tab[4], "%d", Chunk_Size);
argv_tab[5] = verbose_level_str;
sprintf( argv_tab[5], "%d", Verbose_Level);
argv_tab[6] = NULL;
if( Do_Fork_Exec( argv_tab, SON_SND_ID, inst_id, 1, pipe_desc, Verbose_Level) == -1)
{
error = 1;
}
else
{
argv_tab[0] = son_cmd;
Make_Son_Cmd_Name( argv_tab[0], ArgV[0], SON_RCV_NAME);
argv_tab[1] = inst_id_str;
sprintf( argv_tab[1], "%d", inst_id);
argv_tab[2] = Heap_Name;
argv_tab[3] = verbose_level_str;
sprintf( argv_tab[3], "%d", Verbose_Level);
argv_tab[4] = NULL;
if( Do_Fork_Exec( argv_tab, SON_RCV_ID, inst_id, 0, pipe_desc, Verbose_Level) == -1)
{
error = 1;
}
else
{
if( ( rc = close( pipe_desc[ 0])) == -1)
{
Log_Print( LOG_ERROR, Verbose_Level, FATHER_ID, 0, "close() pipe[0] failed: (%d)\n", errno);
}
if( ( rc = close( pipe_desc[ 1])) == -1)
{
Log_Print( LOG_ERROR, Verbose_Level, FATHER_ID, 0, "close() pipe[1] failed: (%d)\n", errno);
}
}
}
}
}
if( error == 0)
{
Log_Print( LOG_TRACE, Verbose_Level, FATHER_ID, 0, "Waiting sons to complet...\n");
for( inst_id = 0; inst_id < ( Inst_Nb * 2); inst_id++)
{
pid = wait( NULL);
Log_Print( LOG_TRACE, Verbose_Level, FATHER_ID, 0, "Son PId: (%d) exited !\n", pid);
}
}
if( ( ( status = SM_Heap_Lock( heap_ptr, SMD_WRITE, &locked)) != SMS_OK) && ( locked == TRUE))
{
Log_Print( LOG_ERROR, Verbose_Level, FATHER_ID, 0, "Can't lock heap (%d) !\n", status);
}
else
{
if( ( status = SM_Heap_Close( heap_ptr)) != SMS_OK)
{
Log_Print( LOG_ERROR, Verbose_Level, FATHER_ID, 0, "Can't close heap (%d) !\n", status);
}
else
{
Log_Print( LOG_TRACE, Verbose_Level, FATHER_ID, 0, "Heap closed !\n");
}
}
}
if( ( status = SM_Library_Close( SMD_CLOSE)) != SMS_OK)
{
Log_Print( LOG_ERROR, Verbose_Level, FATHER_ID, 0, "Can't close LibShMem (%d) !\n", status);
exit( -1);
}
else
{
Log_Print( LOG_TRACE, Verbose_Level, FATHER_ID, 0, "LibShMem closed !\n");
}
exit( 0);
}

204
demo/smdemo0_rcv.c Normal file
View File

@@ -0,0 +1,204 @@
/*---------------------------------------------------------------------------------*/
/* $RCSfile: smdemo0_rcv.c,v $ */
/*---------------------------------------------------------------------------------*/
/* $Revision: 1.1 $ */
/* $Name: $ */
/* $Date: 2005/06/26 23:16:38 $ */
/* $Author: agibert $ */
/*---------------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------------*/
/* This file is a program test 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 <string.h>
#include <stdarg.h>
#include <unistd.h>
#include <errno.h>
#include <node.h>
#ifndef SM_MODE
# define SM_MODE 0 /* Utilisation des API sécurisés */
#endif
#include <shmem.h>
#define LOG_ERROR 10
#define LOG_WARNING 20
#define LOG_INFO 30
#define LOG_TRACE 40
void Log_Print( int, int, int, char *, ...);
int main( int, char **);
void Log_Print( int Log_Level, int Verbose_Level, int Inst_Id, char *Format_Str, ...)
{
va_list args;
char *prompt = "rcv";
int fmt_size = 255;
char fmt[fmt_size + 1];
if( Log_Level <= Verbose_Level)
{
va_start( args, Format_Str);
snprintf( fmt, fmt_size, "%s%02d : %s", prompt, Inst_Id, Format_Str);
vfprintf( stderr, fmt, args);
fflush( stderr);
va_end( args);
}
}
int main( int ArgC, char **ArgV)
{
int Inst_Id;
char *Heap_Name;
int Verbose_Level = 30;
SMT_Heap *heap_ptr;
int locked;
SMT_Status status = SMS_OK;
char *chunk_ptr;
int chunk_id = 0;
char input_str[100];
size_t input_size = 99;
if( ArgC != 4)
{
Log_Print( LOG_ERROR, Verbose_Level, 0, "Usage: %s Inst_Id Heap_Name Verbose_Level\n", ArgV[0]);
exit( -1);
}
else
{
Inst_Id = atoi( ArgV[1]);
Heap_Name = ArgV[2];
Verbose_Level = atoi( ArgV[3]);
Log_Print( LOG_INFO, Verbose_Level, Inst_Id, "Inst_Id: (%d) Heap_Name: [%s] Verbose_Level: (%d)...\n",
Inst_Id, Heap_Name, Verbose_Level);
fflush( stderr);
}
if( ( status = SM_Library_Open( 0, NULL, ( SMD_OPEN | SMD_DEBUG_ALL))) != SMS_OK)
{
Log_Print( LOG_ERROR, Verbose_Level, Inst_Id, "Can't open LibShMem (%d) !\n", status);
exit( -1);
}
Log_Print( LOG_TRACE, Verbose_Level, Inst_Id, "LibShMem opened !\n");
if( ( status = SM_Heap_Open( Heap_Name, &heap_ptr, 0, ( SMD_OPEN | SMD_NO_LOCK), &locked)) != SMS_OK)
{
Log_Print( LOG_ERROR, Verbose_Level, Inst_Id, "Can't open heap (%d) !\n", status);
}
else
{
Log_Print( LOG_TRACE, Verbose_Level, Inst_Id, "Heap opened !\n");
while( ( fgets( input_str, input_size, stdin) != NULL) && ( status == SMS_OK))
{
if( ( chunk_ptr = (char *)atol( input_str)) == NULL)
{
Log_Print( LOG_ERROR, Verbose_Level, Inst_Id, "Garbage on stdin [%s], skiping !\n", input_str);
}
else
{
Log_Print( LOG_TRACE, Verbose_Level, Inst_Id, "Received message: [%s] Id: (%d) Address: (%lu)\n", chunk_ptr, chunk_id, chunk_ptr);
chunk_id++;
if( ( ( status = SM_Heap_Lock( heap_ptr, SMD_WRITE, &locked)) != SMS_OK) && ( locked == TRUE))
{
Log_Print( LOG_ERROR, Verbose_Level, Inst_Id, "Can't lock heap (%d) !\n", status);
}
else
{
if( ( status = SM_Chunk_Free( heap_ptr, chunk_ptr)) != SMS_OK)
{
Log_Print( LOG_ERROR, Verbose_Level, Inst_Id, "Can't free chunk (%d) !\n", status);
}
else
{
Log_Print( LOG_TRACE, Verbose_Level, Inst_Id, "Chunk: (%lu) freed !\n", chunk_ptr);
if( ( status = SM_Heap_Unlock( heap_ptr)) != SMS_OK)
{
Log_Print( LOG_ERROR, Verbose_Level, Inst_Id, "Can't unlock heap (%d) !\n", status);
}
}
}
}
}
Log_Print( LOG_INFO, Verbose_Level, Inst_Id, "Number of message received: (%d) !\n", chunk_id);
if( ( ( status = SM_Heap_Lock( heap_ptr, SMD_WRITE, &locked)) != SMS_OK) && ( locked == TRUE))
{
Log_Print( LOG_ERROR, Verbose_Level, Inst_Id, "Can't lock heap (%d) !\n", status);
}
else
{
if( ( status = SM_Heap_Close( heap_ptr)) != SMS_OK)
{
Log_Print( LOG_ERROR, Verbose_Level, Inst_Id, "Can't close heap (%d) !\n", status);
}
else
{
Log_Print( LOG_TRACE, Verbose_Level, Inst_Id, "Heap closed !\n");
}
}
}
if( ( status = SM_Library_Close( SMD_CLOSE)) != SMS_OK)
{
Log_Print( LOG_ERROR, Verbose_Level, Inst_Id, "Can't close LibShMem (%d) !\n", status);
exit( -1);
}
else
{
Log_Print( LOG_TRACE, Verbose_Level, Inst_Id, "LibShMem closed !\n");
}
exit( 0);
}

204
demo/smdemo0_snd.c Normal file
View File

@@ -0,0 +1,204 @@
/*---------------------------------------------------------------------------------*/
/* $RCSfile: smdemo0_snd.c,v $ */
/*---------------------------------------------------------------------------------*/
/* $Revision: 1.1 $ */
/* $Name: $ */
/* $Date: 2005/06/26 23:16:38 $ */
/* $Author: agibert $ */
/*---------------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------------*/
/* This file is a program test 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 <string.h>
#include <stdarg.h>
#include <unistd.h>
#include <errno.h>
#include <node.h>
#ifndef SM_MODE
# define SM_MODE 0 /* Utilisation des API sécurisés */
#endif
#include <shmem.h>
#define LOG_ERROR 10
#define LOG_WARNING 20
#define LOG_INFO 30
#define LOG_TRACE 40
void Log_Print( int, int, int, char *, ...);
int main( int ArgC, char **ArgV);
void Log_Print( int Log_Level, int Verbose_Level, int Inst_Id, char *Format_Str, ...)
{
va_list args;
char *prompt = "snd";
int fmt_size = 255;
char fmt[ fmt_size + 1];
if( Log_Level <= Verbose_Level)
{
va_start( args, Format_Str);
snprintf( fmt, fmt_size, "%s%02d : %s", prompt, Inst_Id, Format_Str);
vfprintf( stderr, fmt, args);
fflush( stderr);
va_end( args);
}
}
int main( int ArgC, char **ArgV)
{
int Inst_Id;
char *Heap_Name;
int Chunk_Nb;
size_t Chunk_Size;
int Verbose_Level = 30;
SMT_Heap *heap_ptr;
size_t heap_size = 1024;
int locked;
SMT_Status status;
char *chunk_ptr;
int chunk_id;
if( ArgC != 6)
{
Log_Print( LOG_ERROR, Verbose_Level, 0, "Usage: %s Inst_Id Heap_Name Chunck_Nb Chunk_Size Verbose_Level\n", ArgV[0]);
exit( -1);
}
else
{
Inst_Id = atoi( ArgV[1]);
Heap_Name = ArgV[2];
Chunk_Nb = atoi( ArgV[3]);
Chunk_Size = atoi( ArgV[4]);
Verbose_Level = atoi( ArgV[5]);
Log_Print( LOG_INFO, Verbose_Level, Inst_Id, "Inst_Id: (%d) Heap_Name: [%s] Chunck_Nb: (%d) Chunck_Size: (%d) Verbose_Level: (%d)...\n",
Inst_Id, Heap_Name, Chunk_Nb, Chunk_Size, Verbose_Level);
}
if( ( status = SM_Library_Open( 0, NULL, ( SMD_OPEN | SMD_DEBUG_ALL))) != SMS_OK)
{
Log_Print( LOG_ERROR, Verbose_Level, Inst_Id, "Can't open LibShMem (%d) !\n", status);
exit( -1);
}
Log_Print( LOG_TRACE, Verbose_Level, Inst_Id, "LibShMem opened !\n");
if( ( status = SM_Heap_Open( Heap_Name, &heap_ptr, heap_size, ( SMD_OPEN | SMD_NO_LOCK), &locked)) != SMS_OK)
{
Log_Print( LOG_ERROR, Verbose_Level, Inst_Id, "Can't open heap (%d) !\n", status);
}
else
{
Log_Print( LOG_TRACE, Verbose_Level, Inst_Id, "Heap opened !\n");
for( chunk_id = 0; ( chunk_id < Chunk_Nb) && ( status == SMS_OK); chunk_id++)
{
if( ( ( status = SM_Heap_Lock( heap_ptr, SMD_WRITE, &locked)) != SMS_OK) && ( locked == TRUE))
{
Log_Print( LOG_ERROR, Verbose_Level, Inst_Id, "Can't lock heap (%d) !\n", status);
}
else
{
if( ( status = SM_Chunk_Alloc( heap_ptr, Chunk_Size, (void **)&chunk_ptr)) != SMS_OK)
{
Log_Print( LOG_ERROR, Verbose_Level, Inst_Id, "Can't alloc chunk (%d) !\n", status);
}
else
{
if( ( status = SM_Heap_Unlock( heap_ptr)) != SMS_OK)
{
Log_Print( LOG_ERROR, Verbose_Level, Inst_Id, "Can't unlock heap (%d) !\n", status);
}
else
{
Log_Print( LOG_TRACE, Verbose_Level, Inst_Id, "Chunk allocated !\n");
snprintf( chunk_ptr, Chunk_Size, "Hello brother: (%d) !", chunk_id);
Log_Print( LOG_TRACE, Verbose_Level, Inst_Id, "Message: [%s] writen into the chunk: (%lu)\n", chunk_ptr, chunk_ptr);
fprintf( stdout, "%lu\n", chunk_ptr);
fflush( stdout);
}
}
}
}
Log_Print( LOG_INFO, Verbose_Level, Inst_Id, "Number of message sendeded: (%d) !\n", chunk_id);
if( ( ( status = SM_Heap_Lock( heap_ptr, SMD_WRITE, &locked)) != SMS_OK) && ( locked == TRUE))
{
Log_Print( LOG_ERROR, Verbose_Level, Inst_Id, "Can't lock heap (%d) !\n", status);
}
else
{
if( ( status = SM_Heap_Close( heap_ptr)) != SMS_OK)
{
Log_Print( LOG_ERROR, Verbose_Level, Inst_Id, "Can't close heap (%d) !\n", status);
}
else
{
Log_Print( LOG_TRACE, Verbose_Level, Inst_Id, "Heap closed !\n");
}
}
}
if( ( status = SM_Library_Close( SMD_CLOSE)) != SMS_OK)
{
Log_Print( LOG_ERROR, Verbose_Level, Inst_Id, "Can't close LibShMem (%d) !\n", status);
exit( -1);
}
else
{
Log_Print( LOG_TRACE, Verbose_Level, Inst_Id, "LibShMem closed !\n");
}
exit( 0);
}

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

48
include/shmem.h
View File

@@ -1,3 +1,34 @@
/*---------------------------------------------------------------------------------*/
/* $RCSfile: shmem.h,v $ */
/*---------------------------------------------------------------------------------*/
/* $Revision: 2.3 $ */
/* $Name: $ */
/* $Date: 2005/06/26 23:07:40 $ */
/* $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
@@ -144,13 +175,13 @@ char SM_Error_Msg [512];
/*------------------------------------------------------------------------------*/
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 */
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 */
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 */
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 */
@@ -167,15 +198,16 @@ SMT_Base * SM_Base;
typedef struct {
char Name [256]; /* Nom du heap */
int SemID; /* ID du sémaphore pour la gestion des verrous */
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 */
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é */
long Compress_Nb; /* Nomber of time the heap has been compressed */
} SMT_MHH;
/* Heap ouvert */
@@ -193,7 +225,7 @@ typedef struct {
/*------------------------------------------------------------------------------*/
typedef struct {
int MemID; /* ID de la zone de mémoire partagée */
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;

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)

2944
lib/libshmem.c
View File

File diff suppressed because it is too large Load Diff

84
lib/libshmem.h
View File

@@ -1,19 +1,59 @@
/*---------------------------------------------------------------------------------*/
/* $RCSfile: libshmem.h,v $ */
/*---------------------------------------------------------------------------------*/
/* $Revision: 2.3 $ */
/* $Name: $ */
/* $Date: 2005/06/26 23:02:35 $ */
/* $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,6 +80,7 @@ extern char * strdup (const char *);
char Info_Msg [256];
/* Etats possibles pour un heap */
#define SMD_STATE_VALID 0
@@ -120,22 +167,22 @@ typedef union 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,17 +232,7 @@ SMT_Status SM_MHH_End (SMT_MHH *);
/*------------------------------------------------------------------------------*/
/* Fonction manager pour un DSR (Data Segment Root) */
/*------------------------------------------------------------------------------*/
NDT_Status SM_DSR_Manager (va_list);
/*------------------------------------------------------------------------------*/
/* Initialisation d'un nouveau segment de données (noeud du DSR) */
/*------------------------------------------------------------------------------*/
SMT_DSH *SM_DataSegment_Init (SMT_MHH *, size_t);
/*------------------------------------------------------------------------------*/
/* Terminaison d'un segment de données */
/*------------------------------------------------------------------------------*/
SMT_Status SM_DataSegment_End (NDT_Root *, SMT_DSH *);
NDT_Status SM_DSR_Manager( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list);
/*------------------------------------------------------------------------------*/
/* Ouverture d'un segment de données */
@@ -215,12 +252,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 +284,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)

121
util/smadmin.c
View File

@@ -3,10 +3,14 @@
#include <string.h>
#include <stdarg.h>
#include <node.h>
#ifndef SM_MODE
# define SM_MODE 0 /* Utilisation des API sécurisés */
#endif
#include <shmem.h>
VER_INFO_EXPORT (smadmin, "$Revision: 1.1 $", "$Name: $", __FILE__, "$Author: smas $")
//VER_INFO_EXPORT (smadmin, "$Revision: 2.3 $", "$Name: $", __FILE__, "$Author: agibert $")
#define USAGE "Usage : %s [ --help | --version [-v] | --create | --destroy ]\n"
@@ -30,8 +34,15 @@ VER_INFO_EXPORT (smadmin, "$Revision: 1.1 $", "$Name: $", __FILE__, "$Author: s
#define ACR_DUMP 17
#define FCR_DUMP 18
#define NAME_LEN 100
#define NAME_SIZE ( NAME_LEN + 1)
#define TMP_LEN 100
#define TMP_SIZE ( TMP_LEN + 1)
char menu [1000];
char tmp [100];
char tmp [TMP_SIZE];
void init_menu (void);
int print_menu (void);
@@ -39,7 +50,7 @@ int print_menu (void);
int main (int argc, char ** argv)
{
int choice;
char name [100];
char name [NAME_SIZE];
int Mode, Locked;
void * ptr;
char answer [10];
@@ -56,13 +67,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)
@@ -127,10 +138,14 @@ int main (int argc, char ** argv)
case MHH_INIT:
fprintf (stdout, "\nNew heap name ? ");
gets (name);
fgets( name, NAME_SIZE, stdin);
name[ strlen( name) - 1] = '\0';
fprintf (stdout, "\nHeap segment size ? ");
gets (tmp);
size = atoi (tmp);
fgets( tmp, NAME_SIZE, stdin);
tmp[ strlen( tmp) - 1] = '\0';
size = atol (tmp);
fprintf (stdout, "\nReturn code = %s\n", \
SM_Heap_Open (name, &Heap, size, \
SMD_CREATE, &Locked) == SMS_OK ? "OK" : "NOK" );
@@ -138,9 +153,13 @@ int main (int argc, char ** argv)
case MHH_OPEN:
fprintf (stdout, "\nHeap name to open ? ");
gets (name);
fgets( name, NAME_SIZE, stdin);
name[ strlen( name) - 1] = '\0';
fprintf (stdout, "\nOpening mode (read=1 write=2) ? ");
gets (tmp);
fgets( tmp, TMP_SIZE, stdin);
tmp[ strlen( tmp) - 1] = '\0';
if (tmp[0] == '1') Mode = SMD_READ;
else Mode = SMD_WRITE;
if (!strcmp (name, HEAP_SYSTEM))
@@ -157,7 +176,9 @@ int main (int argc, char ** argv)
case MHH_COMPRESS:
fprintf (stdout, "\nHeap name à compresser ? ");
gets (name);
fgets( name, NAME_SIZE, stdin);
name[ strlen( name) - 1] = '\0';
if (SM_Heap_Open (name, &Heap, 0, SMD_OPEN | SMD_WRITE, &Locked) == SMS_OK)
{
size_t Compress;
@@ -169,7 +190,9 @@ int main (int argc, char ** argv)
case MHH_END:
fprintf (stdout, "\nHeap name to remove ? ");
gets (name);
fgets( name, NAME_SIZE, stdin);
name[ strlen( name) - 1] = '\0';
if (!strcmp (name, HEAP_SYSTEM))
{
fprintf (stdout, \
@@ -184,7 +207,9 @@ int main (int argc, char ** argv)
case MHH_CLOSE:
fprintf (stdout, "\nHeap name to close ? ");
gets (name);
fgets( name, NAME_SIZE, stdin);
name[ strlen( name) - 1] = '\0';
if (!strcmp (name, HEAP_SYSTEM))
{
fprintf (stdout, \
@@ -201,7 +226,9 @@ int main (int argc, char ** argv)
case MHH_CHECK:
fprintf (stdout, "\nHeap name to check/recover ? ");
gets (name);
fgets( name, NAME_SIZE, stdin);
name[ strlen( name) - 1] = '\0';
if (SM_Heap_Open (name, &Heap, 0, SMD_OPEN | SMD_WRITE, &Locked) == SMS_OK)
{
Nb_Detected = Nb_Corrected = 0;
@@ -212,41 +239,55 @@ int main (int argc, char ** argv)
case ALLOC_CHUNK:
fprintf (stdout, "\nHeap name ? ");
gets (name);
fgets( name, NAME_SIZE, stdin);
name[ strlen( name) - 1] = '\0';
fprintf (stdout, "\nAllocation size ? ");
gets (tmp);
size = atoi (tmp);
fgets( tmp, TMP_SIZE, stdin);
tmp[ strlen( tmp) - 1] = '\0';
size = atol (tmp);
if (SM_Heap_Open (name, &Heap, 0, SMD_OPEN | SMD_WRITE, &Locked) == SMS_OK)
{
SM_Chunk_Alloc (Heap, size, &ptr);
if (Locked == TRUE) SM_Heap_Unlock (Heap);
}
fprintf (stdout, "\nAddress = 0x%p (%d)\n", ptr, (unsigned int)ptr);
fprintf (stdout, "\nAddress = 0x%p (%lu)\n", ptr, ptr);
break;
case WRITE_CHUNK:
fprintf (stdout, "\nAddress ? ");
gets (tmp);
ptr = (void *)atoi (tmp);
fgets( tmp, TMP_SIZE, stdin);
tmp[ strlen( tmp) - 1] = '\0';
ptr = (void *)atol (tmp);
fprintf (stdout, "\nString to put in ? ");
gets (tmp);
fgets( tmp, TMP_SIZE, stdin);
tmp[ strlen( tmp) - 1] = '\0';
strcpy ( (char *)ptr, tmp);
fprintf (stdout, "\nOK\n");
break;
case READ_CHUNK:
fprintf (stdout, "\nAddress ? ");
gets (tmp);
ptr = (void *)atoi (tmp);
fgets( tmp, TMP_SIZE, stdin);
tmp[ strlen( tmp) - 1] = '\0';
ptr = (void *)atol (tmp);
fprintf (stdout, "\nValeur du pointeur = %s\n", (char *)ptr);
break;
case FREE_CHUNK:
fprintf (stdout, "\nHeap name ? ");
gets (name);
fgets( name, NAME_SIZE, stdin);
name[ strlen( name) - 1] = '\0';
fprintf (stdout, "\nAddress ? ");
gets (tmp);
ptr = (void *)atoi (tmp);
fgets( tmp, TMP_SIZE, stdin);
tmp[ strlen( tmp) - 1] = '\0';
ptr = (void *)atol (tmp);
if (SM_Heap_Open (name, &Heap, 0, SMD_OPEN | SMD_WRITE, &Locked) == SMS_OK)
{
fprintf (stdout, "\nReturn code = %s\n", \
@@ -258,33 +299,39 @@ int main (int argc, char ** argv)
case DSR_DUMP:
fprintf (stdout, "\nHeap name ? ");
gets (name);
fgets( name, NAME_SIZE, stdin);
name[ strlen( name) - 1] = '\0';
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;
case ACR_DUMP:
fprintf (stdout, "\nHeap name ? ");
gets (name);
fgets( name, NAME_SIZE, stdin);
name[ strlen( name) - 1] = '\0';
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;
case FCR_DUMP:
fprintf (stdout, "\nHeap name ? ");
gets (name);
fgets( name, NAME_SIZE, stdin);
name[ strlen( name) - 1] = '\0';
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;
@@ -333,7 +380,9 @@ int print_menu (void)
while (tmp[0] == '\0')
{
printf ("\nChoice ? ");
gets (tmp);
fgets( tmp, TMP_SIZE, stdin);
tmp[ strlen( tmp) - 1] = '\0';
}
return atoi (tmp);