Thank you for implementing the modifications!
I have tested the new version and it works fine. I have also tried the 64bit version of gcc.
It also works fine. Last time I have forgotten to add the option -DNEWLISP64 to CFLAGS and
this was the reason why I got the segmentation fault! That means that gcc is on a par with xlc!
For the sake of completeness I append the make file that I used for gcc (64bit):
Code: Select all
#================== makefile_aixLP64_utf8_gcc (64bit)==========================
# makefile for newLISP v. 10.x.x on AIX with UTF-8 support on PowerPC CPU
#
OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
nl-sock.o nl-import.o nl-xml.o nl-web.o nl-matrix.o nl-debug.o nl-utf8.o pcre.o
# use following for UTF-8 support and add nl-utf8.o to the OBJS line
CFLAGS = -maix64 -Wall -pedantic -fno-strict-aliasing -Wno-uninitialized -Wno-long-long -c -O2 -DNEWLISP64 -DSUPPORT_UTF8 -DAIX
CC = gcc
default: $(OBJS)
$(CC) $(OBJS) -maix64 -lm -ldl -lrt -lnsl -o newlisp
.c.o:
$(CC) $(CFLAGS) $<
$(OBJS): primes.h protos.h makefile_aixLP64_utf8_gcc
#
#==============================================================================
And here is the 32bit version for gcc (to facilitate Copy&Paste if necessary):
Code: Select all
#==================== makefile_aix_utf8_gcc (32bit)============================
# makefile for newLISP v. 10.x.x on AIX with UTF-8 support on PowerPC CPU
#
OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
nl-sock.o nl-import.o nl-xml.o nl-web.o nl-matrix.o nl-debug.o nl-utf8.o pcre.o
# use following for UTF-8 support and add nl-utf8.o to the OBJS line
CFLAGS = -Wall -pedantic -fno-strict-aliasing -Wno-uninitialized -Wno-long-long -c -O2 -DSUPPORT_UTF8 -DAIX
CC = gcc
default: $(OBJS)
$(CC) $(OBJS) -lm -ldl -lrt -lnsl -o newlisp
.c.o:
$(CC) $(CFLAGS) $<
$(OBJS): primes.h protos.h makefile_aix_utf8_gcc
#
#==============================================================================
I would suggest that we modify the Makefile such that both compiler types can be used:
Code: Select all
...
aix64:
gmake -f makefile_aixLP64_utf8_xlc
aix:
gmake -f makefile_aix_utf8_xlc
aix64_gcc:
gmake -f makefile_aixLP64_utf8_gcc
aix_gcc:
gmake -f makefile_aix_utf8_gcc
...
or something like this.
Here is the output of test-map for both gcc and xlc (64bit/32bit):
Code: Select all
# gcc -maix64 test-mmap.c -o test-mmap
# ./test-mmap
pagesize: 4096
address:0x0
# xlc -q64 test-mmap.c -o test-mmap
# ./test-mmap
pagesize: 4096
address:0x0
# gcc test-mmap.c -o test-mmap
# ./test-mmap
pagesize: 4096
address:0x30000000
# xlc test-mmap.c -o test-mmap
# ./test-mmap
pagesize: 4096
address:0x30000000
I agree with you on Cilk API. I find the language features regarding concurrency
and distribution very important from practical point of view (we live in the world
of multicore systems and cocurrency is omnipresent!!)
I have appended the AIX manpage for mmap. Maye it helps!
Code: Select all
Technical Reference: Base Operating System and Extensions, Volume 1
mmap or mmap64 Subroutine
Purpose
Maps a file-system object into virtual memory.
Library
Standard C library (libc.a)
Syntax
#include <sys/types.h>
#include <sys/mman.h>
void *mmap (addr, len, prot, flags, fildes, off)
void * addr;
size_t len;
int prot, flags, fildes;
off_t off;
void *mmap64 (addr, len, prot, flags, fildes, off)
void * addr;
size_t len;
int prot, flags, fildes;
off64_t off;
Description
Attention: A file-system object should not be simultaneously mapped using both the mmap
and shmat subroutines. Unexpected results may occur when references are made beyond the
end of the object.
The mmap subroutine creates a new mapped file or anonymous memory region by establishing
a mapping between a process-address space and a file-system object. Care needs to be
taken when using the mmap subroutine if the program attempts to map itself. If the page
containing executing instructions is currently referenced as data through an mmap
mapping, the program will hang. Use the -H4096 binder option, and that will put the
executable text on page boundaries. Then reset the file that contains the executable
material, and view via an mmap mapping.
A region created by the mmap subroutine cannot be used as the buffer for read or write
operations that involve a device. Similarly, an mmap region cannot be used as the buffer
for operations that require either a pin or xmattach operation on the buffer.
Modifications to a file-system object are seen consistently, whether accessed from a
mapped file region or from the read or write subroutine.
Child processes inherit all mapped regions from the parent process when the fork
subroutine is called. The child process also inherits the same sharing and protection
attributes for these mapped regions. A successful call to any exec subroutine will unmap
all mapped regions created with the mmap subroutine.
The mmap64 subroutine is identical to the mmap subroutine except that the starting
offset for the file mapping is specified as a 64-bit value. This permits file mappings
which start beyond OFF_MAX.
In the large file enabled programming environment, mmap is redefined to be mmap64.
If the application has requested SPEC1170 compliant behavior then the st_atime field of
the mapped file is marked for update upon successful completion of the mmap call.
If the application has requested SPEC1170 compliant behavior then the st_ctime and
st_mtime fields of a file that is mapped with MAP_SHARED and PROT_WRITE are marked for
update at the next call to msync subroutine or munmap subroutine if the file has been
modified.
Parameters
addr
Specifies the starting address of the memory region to be mapped. When the
MAP_FIXED flag is specified, this address must be a multiple of the page size
returned by the sysconf subroutine using the _SC_PAGE_SIZE value for the Name
parameter. A region is never placed at address zero, or at an address where it
would overlap an existing region.
len
Specifies the length, in bytes, of the memory region to be mapped. The system
performs mapping operations over whole pages only. If the len parameter is not a
multiple of the page size, the system will include in any mapping operation the
address range between the end of the region and the end of the page containing the
end of the region.
prot
Specifies the access permissions for the mapped region. The sys/mman.h file defines
the following access options:
PROT_READ
Region can be read.
PROT_WRITE
Region can be written.
PROT_EXEC
Region can be executed.
PROT_NONE
Region cannot be accessed.
The prot parameter can be the PROT_NONE flag, or any combination of the PROT_READ
flag, PROT_WRITE flag, and PROT_EXEC flag logically ORed together. If the PROT_NONE
flag is not specified, access permissions may be granted to the region in addition
to those explicitly requested. However, write access will not be granted unless the
PROT_WRITE flag is specified. Note: The operating system generates a SIGSEGV signal
if a program attempts an access that exceeds the access permission given to a
memory region. For example, if the PROT_WRITE flag is not specified and a program
attempts a write access, a SIGSEGV signal results.
If the region is a mapped file that was mapped with the MAP_SHARED flag, the mmap
subroutine grants read or execute access permission only if the file descriptor
used to map the file was opened for reading. It grants write access permission only
if the file descriptor was opened for writing.
If the region is a mapped file that was mapped with the MAP_PRIVATE flag, the mmap
subroutine grants read, write, or execute access permission only if the file
descriptor used to map the file was opened for reading. If the region is an
anonymous memory region, the mmap subroutine grants all requested access
permissions.
fildes
Specifies the file descriptor of the file-system object or of the shared memory
object to be mapped. If the MAP_ANONYMOUS flag is set, the fildes parameter must be
-1. After the successful completion of the mmap subroutine, the file or the shared
memory object specified by the fildes parameter can be closed without affecting the
mapped region or the contents of the mapped file. Each mapped region creates a file
reference, similar to an open file descriptor, which prevents the file data from
being deallocated. Note: The mmap subroutine supports the mapping of shared memory
object and regular files only. An mmap call that specifies a file descriptor for a
special file fails, returning the ENODEV error code. An example of a file
descriptor for a special file is one that might be used for mapping either I/O or
device memory.
off
Specifies the file byte offset at which the mapping starts. This offset must be a
multiple of the page size returned by the sysconf subroutine using the
_SC_PAGE_SIZE value for the Name parameter.
flags
Specifies attributes of the mapped region. Values for the flags parameter are
constructed by a bitwise-inclusive ORing of values from the following list of
symbolic names defined in the sys/mman.h file:
MAP_FILE
Specifies the creation of a new mapped file region by mapping the file
associated with the fildes file descriptor. The mapped region can extend
beyond the end of the file, both at the time when the mmap subroutine is
called and while the mapping persists. This situation could occur if a file
with no contents was created just before the call to the mmap subroutine, or
if a file was later truncated. However, references to whole pages following
the end of the file result in the delivery of a SIGBUS signal. Only one of
the MAP_FILE and MAP_ANONYMOUS flags must be specified with the mmap
subroutine.
MAP_ANONYMOUS
Specifies the creation of a new, anonymous memory region that is initialized
to all zeros. This memory region can be shared only with the descendants of
the current process. When using this flag, the fildes parameter must be -1.
Only one of the MAP_FILE and MAP_ANONYMOUS flags must be specified with the
mmap subroutine.
MAP_ VARIABLE
Specifies that the system select an address for the new memory region if the
new memory region cannot be mapped at the address specified by the addr
parameter, or if the addr parameter is null. Only one of the MAP_VARIABLE
and MAP_FIXED flags must be specified with the mmap subroutine.
MAP_FIXED
Specifies that the mapped region be placed exactly at the address specified
by the addr parameter. If the application has requested SPEC1170 complaint
behavior and the mmap request is successful, the mapping replaces any
previous mappings for the process' pages in the specified range. If the
application has not requested SPEC1170 compliant behavior and a previous
mapping exists in the range then the request fails. Only one of the
MAP_VARIABLE and MAP_FIXED flags must be specified with the mmap subroutine.
MAP_SHARED
When the MAP_SHARED flag is set, modifications to the mapped memory region
will be visible to other processes that have mapped the same region using
this flag. If the region is a mapped file region, modifications to the
region will be written to the file.
You can specify only one of the MAP_SHARED or MAP_PRIVATE flags with the
mmap subroutine. MAP_PRIVATE is the default setting when neither flag is
specified unless you request SPEC1170 compliant behavior. In this case, you
must choose either MAP_SHARED or MAP_PRIVATE.
MAP_PRIVATE
When the MAP_PRIVATE flag is specified, modifications to the mapped region
by the calling process are not visible to other processes that have mapped
the same region. If the region is a mapped file region, modifications to the
region are not written to the file.
If this flag is specified, the initial write reference to an object page
creates a private copy of that page and redirects the mapping to the copy.
Until then, modifications to the page by processes that have mapped the same
region with the MAP_SHARED flag are visible.
You can specify only one of the MAP_SHARED or MAP_PRIVATE flags with the
mmap subroutine. MAP_PRIVATE is the default setting when neither flag is
specified unless you request SPEC1170 compliant behavior. In this case, you
must choose either MAP_SHARED or MAP_PRIVATE.
Return Values
If successful, the mmap subroutine returns the address at which the mapping was placed.
Otherwise, it returns -1 and sets the errno global variable to indicate the error.
Error Codes
Under the following conditions, the mmap subroutine fails and sets the errno global
variable to:
EACCES
The file referred to by the fildes parameter is not open for read access, or the
file is not open for write access and the PROT_WRITE flag was specified for a
MAP_SHARED mapping operation. Or, the file to be mapped has enforced locking
enabled and the file is currently locked.
EAGAIN
The fildes parameter refers to a device that has already been mapped.
EBADF
The fildes parameter is not a valid file descriptor, or the MAP_ANONYMOUS flag was
set and the fildes parameter is not -1.
EFBIG
The mapping requested extends beyond the maximum file size associated with fildes.
EINVAL
The flags or prot parameter is invalid, or the addr parameter or off parameter is
not a multiple of the page size returned by the sysconf subroutine using the
_SC_PAGE_SIZE value for the Name parameter.
EINVAL
The application has requested SPEC1170 compliant behavior and the value of flags is
invalid (neither MAP_PRIVATE nor MAP_SHARED is set).
EMFILE
The application has requested SPEC1170 compliant behavior and the number of mapped
regions would excedd and implementation-dependent limit (per process or per
system).
ENODEV
The fildes parameter refers to an object that cannot be mapped, such as a terminal.
ENOMEM
There is not enough address space to map len bytes, or the application has not
requested Single UNIX Specification, Version 2 compliant behavior and the MAP_FIXED
flag was set and part of the address-space range (addr, addr+len) is already
allocated.
ENXIO
The addresses specified by the range (off, off+len) are invalid for the fildes
parameter.
EOVERFLOW
The mapping requested extends beyond the offset maximum for the file description
associated with fildes.
Related Information
The exec (exec: execl, execle, execlp, execv, execve, execvp, or exect Subroutine)
subroutine, fork (fork, f_fork, or vfork Subroutine) subroutine, munmap (munmap
Subroutine) subroutine, read subroutine, shm_open subroutine, shm_unlink subroutine,
shmat subroutine, sysconf subroutine, write subroutine.
The pin kernel service, xmattach kernel service.
List of Memory Manipulation Services, List of Memory Mapping Services, Understanding
Memory Mapping in AIX 5L Version 5.3 General Programming Concepts: Writing and Debugging
Programs.