Menu
▾
▴
clisp-cvs digest, Vol 1 #528 - 2 msgs
|
From: <cli...@li...> - 2004-05-26 15:01:17
|
Send clisp-cvs mailing list submissions to cli...@li... To subscribe or unsubscribe via the World Wide Web, visit https://lists.sourceforge.net/lists/listinfo/clisp-cvs or, via email, send a message with subject or body 'help' to cli...@li... You can reach the person managing the list at cli...@li... When replying, please edit your Subject line so it is more specific than "Re: Contents of clisp-cvs digest..." CLISP CVS commits for today Today's Topics: 1. clisp/utils modprep.lisp,1.6,1.6.2.1 modpreptest.out,1.4,1.4.2.1 (Bruno Haible) 2. clisp/src lispbibl.d,1.435.2.11,1.435.2.12 spvw.d,1.267.2.2,1.267.2.3 spvwtabf.d,1.4,1.4.2.1 spvwtabs.d,1.6,1.6.2.1 spvw_garcol.d,1.61.2.1,1.61.2.2 spvw_memfile.d,1.64,1.64.2.1 genclisph.d,1.99.2.7,1.99.2.8 modules.d,1.12,1.12.2.1 affi.d,1.28,1.28.2.1 spvw_heap.d,1.9,1.9.2.1 spvw_allocate.d,1.19,1.19.2.1 spvw_global.d,1.12,1.12.2.1 spvw_genera1.d,1.22.2.1,1.22.2.2 ChangeLog,1.2750.2.40,1.2750.2.41 (Bruno Haible) --__--__-- Message: 1 From: Bruno Haible <ha...@us...> To: cli...@li... Subject: clisp/utils modprep.lisp,1.6,1.6.2.1 modpreptest.out,1.4,1.4.2.1 Date: Wed, 26 May 2004 14:59:32 +0000 Reply-To: cli...@li... Update of /cvsroot/clisp/clisp/utils In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv12456/utils Modified Files: Tag: clisp_2_33-patched modprep.lisp modpreptest.out Log Message: Make it possible to enforce an alignment == 4 mod 8 in HEAPCODES mode. Index: modprep.lisp =================================================================== RCS file: /cvsroot/clisp/clisp/utils/modprep.lisp,v retrieving revision 1.6 retrieving revision 1.6.2.1 diff -u -d -r1.6 -r1.6.2.1 --- modprep.lisp 16 Mar 2004 14:33:34 -0000 1.6 +++ modprep.lisp 26 May 2004 14:59:29 -0000 1.6.2.1 @@ -737,6 +737,7 @@ (write-string " 0" out) (newline out) (write-string "};" out) (newline out) (newline out) (format out "struct ~A_t {" subr-tab) (newline out) + (write-string " VAROBJECTS_ALIGNMENT_DUMMY_DECL" out) (newline out) (loop :for fd :across *fundefs* :do (with-conditional (out (fundef-cond-stack fd)) (format out " subr_t _~A;" (fundef-tag fd)))) @@ -750,7 +751,14 @@ (subr-tab (ext:string-concat "module__" *module-name* "__subr_tab"))) (newline out) (newline out) - (format out "struct ~A_t ~A = {" subr-tab subr-tab) (newline out) + (format out "struct ~A_t ~A" subr-tab subr-tab) (newline out) + (write-string " #if defined(HEAPCODES) && (alignment_long < varobject_alignment) && defined(__GNUC__)" out) (newline out) + (write-string " __attribute__ ((aligned (varobject_alignment)))" out) (newline out) + (write-string " #endif" out) (newline out) + (write-string " = {" out) (newline out) + (write-string " #if varobjects_misaligned" out) (newline out) + (write-string " { 0 }," out) (newline out) + (write-string " #endif" out) (newline out) (loop :for fd :across *fundefs* :do (setf (fundef-signatures fd) (nreverse (fundef-signatures fd))) (loop :for sig :in (fundef-signatures fd) :do @@ -758,7 +766,7 @@ (format out " LISPFUN_F~A" (fundef-lispfun fd sig))))) (write-string " 0" out) (newline out) (write-string "};" out) (newline out) - (format out "uintC module__~A__subr_tab_size = (sizeof(struct ~A_t)-sizeof(int))/sizeof(subr_t);" *module-name* subr-tab) + (format out "uintC module__~A__subr_tab_size = (sizeof(struct ~A_t)-varobjects_misaligned-sizeof(int))/sizeof(subr_t);" *module-name* subr-tab) (newline out) (newline out) (write-string "struct {" out) (newline out) (loop :for fd :across *fundefs* Index: modpreptest.out =================================================================== RCS file: /cvsroot/clisp/clisp/utils/modpreptest.out,v retrieving revision 1.4 retrieving revision 1.4.2.1 diff -u -d -r1.4 -r1.4.2.1 --- modpreptest.out 16 Mar 2004 14:33:34 -0000 1.4 +++ modpreptest.out 26 May 2004 14:59:30 -0000 1.4.2.1 @@ -130,6 +130,7 @@ #endif struct { + VAROBJECTS_ALIGNMENT_DUMMY_DECL #if defined(cond0) subr_ _subr_mypack__fun1; #endif @@ -141,16 +142,21 @@ subr_t _subr_user__fun5; int _dummy_to_avoid_trailing_comma_in_initializer; } module__sample__subr_tab = { + #if varobjects_misaligned + { 0 }, + #endif + { #if defined(cond0) - LISPFUN_F(subr_mypack__fun1,1,0,norest,nokey,0,NIL) + LISPFUN_F(subr_mypack__fun1,1,0,norest,nokey,0,NIL) #endif #if ((defined(cond0)) && (defined(cond1))) || ((defined(cond0)) && (!(defined(cond1)))) - LISPFUN_F(subr_mypack__fun2,1,0,norest,nokey,0,NIL) + LISPFUN_F(subr_mypack__fun2,1,0,norest,nokey,0,NIL) #endif - LISPFUN_F(subr_mypack__fun3,2,1,norest,nokey,0,NIL) - LISPFUN_F(subr_mypack__fun4,2,0,norest,key,2,NIL) - LISPFUN_F(subr_user__fun5,2,0,rest,nokey,0,NIL) - 0 + LISPFUN_F(subr_mypack__fun3,2,1,norest,nokey,0,NIL) + LISPFUN_F(subr_mypack__fun4,2,0,norest,key,2,NIL) + LISPFUN_F(subr_user__fun5,2,0,rest,nokey,0,NIL) + 0 + } }; uintC module__sample__subr_tab_size = (sizeof(struct module__sample__subr_tab_t)-sizeof(int))/sizeof(subr_t); --__--__-- Message: 2 From: Bruno Haible <ha...@us...> To: cli...@li... Subject: clisp/src lispbibl.d,1.435.2.11,1.435.2.12 spvw.d,1.267.2.2,1.267.2.3 spvwtabf.d,1.4,1.4.2.1 spvwtabs.d,1.6,1.6.2.1 spvw_garcol.d,1.61.2.1,1.61.2.2 spvw_memfile.d,1.64,1.64.2.1 genclisph.d,1.99.2.7,1.99.2.8 modules.d,1.12,1.12.2.1 affi.d,1.28,1.28.2.1 spvw_heap.d,1.9,1.9.2.1 spvw_allocate.d,1.19,1.19.2.1 spvw_global.d,1.12,1.12.2.1 spvw_genera1.d,1.22.2.1,1.22.2.2 ChangeLog,1.2750.2.40,1.2750.2.41 Date: Wed, 26 May 2004 14:59:31 +0000 Reply-To: cli...@li... Update of /cvsroot/clisp/clisp/src In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv12456/src Modified Files: Tag: clisp_2_33-patched lispbibl.d spvw.d spvwtabf.d spvwtabs.d spvw_garcol.d spvw_memfile.d genclisph.d modules.d affi.d spvw_heap.d spvw_allocate.d spvw_global.d spvw_genera1.d ChangeLog Log Message: Make it possible to enforce an alignment == 4 mod 8 in HEAPCODES mode. Index: modules.d =================================================================== RCS file: /cvsroot/clisp/clisp/src/modules.d,v retrieving revision 1.12 retrieving revision 1.12.2.1 diff -u -d -r1.12 -r1.12.2.1 --- modules.d 22 Aug 2003 21:04:03 -0000 1.12 +++ modules.d 26 May 2004 14:59:28 -0000 1.12.2.1 @@ -1,6 +1,6 @@ /* * Module für CLISP - * Bruno Haible 1994-2003 + * Bruno Haible 1994-2004 */ /* All dependencies on modules.h are collected here! */ @@ -22,7 +22,8 @@ extern uintC subr_tab_data_size; extern uintC object_tab_size; #define MODULE(module_name) \ - extern subr_t module__##module_name##__subr_tab[]; \ + extern struct { VAROBJECTS_ALIGNMENT_DUMMY_DECL subr_t subrs[1]; } \ + module__##module_name##__subr_tab; \ extern uintC module__##module_name##__subr_tab_size; \ extern gcv_object_t module__##module_name##__object_tab[]; \ extern uintC module__##module_name##__object_tab_size; \ @@ -39,13 +40,13 @@ #endif module_t modules[] = { { "clisp", - (subr_t*)&subr_tab_data, &subr_tab_data_size, + (subr_t*)((char*)&subr_tab_data+varobjects_misaligned), &subr_tab_data_size, (gcv_object_t*)&object_tab, &object_tab_size, true, NULL, NULL, NULL, NULL _NEXT_NULL }, #define MODULE(module_name) \ { #module_name, /* cannot use STRING(): module_name may be a CPP macro */ \ - &module__##module_name##__subr_tab[0], \ + &module__##module_name##__subr_tab.subrs[0], \ &module__##module_name##__subr_tab_size, \ &module__##module_name##__object_tab[0], \ &module__##module_name##__object_tab_size, \ Index: spvw_memfile.d =================================================================== RCS file: /cvsroot/clisp/clisp/src/spvw_memfile.d,v retrieving revision 1.64 retrieving revision 1.64.2.1 diff -u -d -r1.64 -r1.64.2.1 --- spvw_memfile.d 14 Mar 2004 14:42:56 -0000 1.64 +++ spvw_memfile.d 26 May 2004 14:59:27 -0000 1.64.2.1 @@ -177,7 +177,7 @@ #define page_alignment map_pagesize #define WRITE_page_alignment(position) \ do { \ - var uintL aligncount = (uintL)(-position) % page_alignment; \ + var uintL aligncount = (uintL)(-(position)) % page_alignment; \ if (aligncount > 0) { /* get a piece of zeroed memory: */ \ var DYNAMIC_ARRAY(zeroes,uintB,aligncount); \ var uintB* ptr = &zeroes[0]; \ @@ -190,7 +190,7 @@ } while(0) #define READ_page_alignment(position) \ do { \ - var uintL aligncount = (uintL)(-position) % page_alignment; \ + var uintL aligncount = (uintL)(-(position)) % page_alignment; \ if (aligncount > 0) { \ var DYNAMIC_ARRAY(dummy,uintB,aligncount); \ READ(&dummy[0],aligncount); \ @@ -411,17 +411,28 @@ { var uintL heapnr; for (heapnr=0; heapnr<heapcount; heapnr++) { + var uintL misaligned = 0; + #if ((defined(SPVW_PURE_BLOCKS) && defined(SINGLEMAP_MEMORY)) || (defined(SPVW_MIXED_BLOCKS_STAGGERED) && defined(TRIVIALMAP_MEMORY))) && (defined(HAVE_MMAP) || defined(SELFMADE_MMAP)) && varobjects_misaligned + if (is_varobject_heap(heapnr)) { + var uintB zeroes[varobjects_misaligned]; + var uintB* ptr = &zeroes[0]; + doconsttimes(varobjects_misaligned, { *ptr++ = 0; } ); + /* write zeroes: */ + WRITE(&zeroes[0],varobjects_misaligned); + misaligned = varobjects_misaligned; + } + #endif #if !defined(GENERATIONAL_GC) map_heap(mem.heaps[heapnr],page, { var uintL len = page->page_end - page->page_start; WRITE(page->page_start,len); - WRITE_page_alignment(len); + WRITE_page_alignment(misaligned+len); }); #else /* defined(GENERATIONAL_GC) */ var Heap* heap = &mem.heaps[heapnr]; var uintL len = heap->heap_gen0_end - heap->heap_gen0_start; WRITE(heap->heap_gen0_start,len); - WRITE_page_alignment(len); + WRITE_page_alignment(misaligned+len); #endif } } @@ -1148,7 +1159,8 @@ var uintC pagecount = pagecounts[heapnr]; while (pagecount!=0) { var uintL need = old_page_ptr->_page_end - old_page_ptr->_page_start; - var uintL size1 = round_up(need,sizeof(cons_)); + var uintL misaligned = mem.heaps[heapnr].misaligned; + var uintL size1 = round_up(misaligned+need,sizeof(cons_)); if (size1 < std_page_size) { size1 = std_page_size; } { var uintL size2 = size1 + sizeof_NODE + (varobject_alignment-1); @@ -1166,7 +1178,7 @@ /* get page from operating system. */ page->m_start = addr; page->m_length = size2; /* initialize: */ - page->page_start = page_start0(page); + page->page_start = page_start0(page) + misaligned; page->page_end = page->page_start + need; page->page_room = size1 - need; /* add to this heap: */ @@ -1214,8 +1226,10 @@ for (heapnr=0; heapnr<heapcount; heapnr++) { var Heap* heapptr = &mem.heaps[heapnr]; var uintL len = heapptr->heap_end - heapptr->heap_start; - var uintL map_len = round_up(len,map_pagesize); - heapptr->heap_limit = heapptr->heap_start + map_len; + var uintL misaligned = + (is_varobject_heap(heapnr) ? varobjects_misaligned : 0); + var uintL map_len = round_up(misaligned+len,map_pagesize); + heapptr->heap_limit = (heapptr->heap_start-misaligned) + map_len; if (map_len > 0) { if (heapptr->heap_limit-1 > heapptr->heap_hardlimit-1) goto abort3; #if defined(HAVE_MMAP) || defined(SELFMADE_MMAP) @@ -1225,7 +1239,7 @@ the page_alignment is necessary for this purpose! */ if (use_mmap) { #ifdef HAVE_MMAP - if (filemap((void*)(heapptr->heap_start),map_len, + if (filemap((void*)(heapptr->heap_start-misaligned),map_len, handle,file_offset) != (void*)(-1)) #endif @@ -1253,10 +1267,16 @@ if ( lseek(handle,file_offset,SEEK_SET) <0) goto abort1; } } - #endif /* HAVE_MMAP) || SELFMADE_MMAP */ - if (zeromap((void*)(heapptr->heap_start),map_len) <0) goto abort3; + #endif /* HAVE_MMAP || SELFMADE_MMAP */ + if (zeromap((void*)(heapptr->heap_start-misaligned),map_len) <0) goto abort3; + #if varobjects_misaligned + if (is_varobject_heap(heapnr)) { + var uintB dummy[varobjects_misaligned]; + READ(&dummy[0],varobjects_misaligned); + } + #endif READ(heapptr->heap_start,len); - READ_page_alignment(len); + READ_page_alignment(misaligned+len); block_done: ; } } @@ -1278,12 +1298,11 @@ #endif /* SPVW_PURE_BLOCKS) || SPVW_MIXED_BLOCKS_STAGGERED */ #ifdef SPVW_MIXED_BLOCKS_OPPOSITE { /* read objects of variable length: */ - var uintL len = header._mem_varobjects_end - - header._mem_varobjects_start; + var uintL len = header._mem_varobjects_end - header._mem_varobjects_start; #ifdef TRIVIALMAP_MEMORY - var uintL map_len = round_up(len,map_pagesize); - mem.varobjects.heap_limit = mem.varobjects.heap_start + map_len; - if (zeromap((void*)mem.varobjects.heap_start,map_len) <0) goto abort3; + var uintL map_len = round_up(len+varobjects_misaligned,map_pagesize); + mem.varobjects.heap_limit = (mem.varobjects.heap_start-varobjects_misaligned) + map_len; + if (zeromap((void*)(mem.varobjects.heap_start-varobjects_misaligned),map_len) <0) goto abort3; #endif READ(mem.varobjects.heap_start,len); } @@ -1434,10 +1453,14 @@ = heap->heap_start & -physpagesize; } else { heap->heap_gen1_start = heap->heap_end - = (heap->heap_end + (physpagesize-1)) & -physpagesize; + = ((heap->heap_end + (physpagesize-1)) & -physpagesize) + varobjects_misaligned; + heap->heap_limit = heap->heap_end; } #else /* defined(SPVW_PURE_BLOCKS) || defined(SPVW_MIXED_BLOCKS_STAGGERED) */ - heap->heap_gen1_start = heap->heap_end = heap->heap_limit; + heap->heap_gen1_start = heap->heap_end + = ((heap->heap_end + (physpagesize-1)) & -physpagesize) + + (is_varobject_heap(heapnr) ? varobjects_misaligned : 0); + heap->heap_limit = heap->heap_end; #endif /* SPVW_MIXED_BLOCKS_OPPOSITE */ #ifdef SPVW_PURE_BLOCKS /* Don't need to rebuild the cache. */ Index: spvw_genera1.d =================================================================== RCS file: /cvsroot/clisp/clisp/src/spvw_genera1.d,v retrieving revision 1.22.2.1 retrieving revision 1.22.2.2 diff -u -d -r1.22.2.1 -r1.22.2.2 --- spvw_genera1.d 26 May 2004 14:48:55 -0000 1.22.2.1 +++ spvw_genera1.d 26 May 2004 14:59:28 -0000 1.22.2.2 @@ -425,6 +425,7 @@ physpage->continued_addr = (gcv_object_t*)gen0_start; # irrelevant physpage->continued_count = 0; physpage->firstobject = gen0_start; + gen0_start &= -physpagesize; gen0_start += physpagesize; physpage++; while (objptr < gen0_end) { var aint nextptr = objptr + size_symbol(); @@ -451,6 +452,7 @@ physpage->continued_addr = (gcv_object_t*)gen0_start; # irrelevant physpage->continued_count = 0; physpage->firstobject = gen0_start; + gen0_start &= -physpagesize; gen0_start += physpagesize; physpage++; while (objptr < gen0_end) { var aint nextptr = objptr + objsize_iarray((Iarray)objptr); @@ -485,6 +487,8 @@ physpage->continued_addr = (gcv_object_t*)gen0_start; # irrelevant physpage->continued_count = 0; physpage->firstobject = gen0_start; + gen0_start &= -physpagesize; + gen0_start &= -physpagesize; gen0_start += physpagesize; physpage++; while (objptr < gen0_end) { var uintL count = svector_length((Svector)objptr); @@ -525,6 +529,7 @@ physpage->continued_addr = (gcv_object_t*)gen0_start; # irrelevant physpage->continued_count = 0; physpage->firstobject = gen0_start; + gen0_start &= -physpagesize; gen0_start += physpagesize; physpage++; while (objptr < gen0_end) { var uintC count; @@ -573,6 +578,7 @@ physpage->continued_addr = (gcv_object_t*)gen0_start; # irrelevant physpage->continued_count = 0; physpage->firstobject = gen0_start; + gen0_start &= -physpagesize; gen0_start += physpagesize; physpage++; while (objptr < gen0_end) { #ifdef TYPECODES Index: spvw_allocate.d =================================================================== RCS file: /cvsroot/clisp/clisp/src/spvw_allocate.d,v retrieving revision 1.19 retrieving revision 1.19.2.1 diff -u -d -r1.19 -r1.19.2.1 --- spvw_allocate.d 16 Jan 2004 11:16:27 -0000 1.19 +++ spvw_allocate.d 26 May 2004 14:59:28 -0000 1.19.2.1 @@ -233,15 +233,15 @@ if (needed_limit <= heapptr->heap_limit) # has the GC done its job? return; # yes -> finished # round up to the next page boundary: - #ifndef GENERATIONAL_GC - needed_limit = round_up(needed_limit,map_pagesize); # for sure > heapptr->heap_limit - #else # map_pagesize is commonly known a power of two needed_limit = (needed_limit + map_pagesize-1) & -map_pagesize; # for suer > heapptr->heap_limit - #endif # allocate new memory: if (needed_limit <= mem.conses.heap_limit) { # avoid crossover + var aint mapstart = heapptr->heap_limit; + #if varobjects_misaligned + mapstart &= -map_pagesize; + #endif begin_system_call(); - var int ergebnis = zeromap((void*)(heapptr->heap_limit),needed_limit - heapptr->heap_limit); + var int ergebnis = zeromap((void*)mapstart,needed_limit - mapstart); end_system_call(); if (ergebnis >= 0) goto sufficient; @@ -295,12 +295,8 @@ goto failed; if (needed_limit >= heapptr->heap_limit) # has the GC done its job? return; # yes -> finished - # round off to the next page boundary: - #ifndef GENERATIONAL_GC - needed_limit = round_down(needed_limit,map_pagesize); # for sure < heapptr->heap_limit - #else # map_pagesize is commonly known a power of two + # round down to the next page boundary: needed_limit = needed_limit & -map_pagesize; # for sure < heapptr->heap_limit - #endif # allocate new memory: if (needed_limit >= mem.varobjects.heap_limit) { # avoid crossover begin_system_call(); @@ -383,8 +379,12 @@ #endif # allocate new memory: if (needed_limit-1 <= heapptr->heap_hardlimit-1) { + var aint mapstart = heapptr->heap_limit; + #if varobjects_misaligned + mapstart &= -map_pagesize; + #endif begin_system_call(); - var int ergebnis = zeromap((void*)(heapptr->heap_limit),needed_limit - heapptr->heap_limit); + var int ergebnis = zeromap((void*)mapstart,needed_limit - mapstart); end_system_call(); if (ergebnis >= 0) goto sufficient; @@ -425,11 +425,13 @@ #define make_space(need,heap_ptr,stack_ptr,pagevar) \ { pagevar = AVL(AVLID,least)(need,&(heap_ptr)->inuse,stack_ptr); \ if (pagevar==EMPTY) \ - pagevar = make_space_gc(need,&(heap_ptr)->inuse,stack_ptr); \ + pagevar = make_space_gc(need,heap_ptr,stack_ptr); \ inc_alloccount(); \ } - local Pages make_space_gc (uintL need, Pages* pages_ptr, AVL(AVLID,stack) * stack_ptr) + local Pages make_space_gc (uintL need, Heap* heap_ptr, AVL(AVLID,stack) * stack_ptr) { + var Pages* pages_ptr = &heap_ptr->inuse; + var uintL misaligned = heap_ptr->misaligned; # AVL(AVLID,least)(need,pages_ptr,stack_ptr) == EMPTY # is already checked, # so there is not enough room. @@ -446,7 +448,7 @@ # try to get space from the operating system: #define make_space_using_malloc() \ do { \ - var uintL size1 = round_up(need,sizeof(cons_)); \ + var uintL size1 = round_up(misaligned+need,sizeof(cons_)); \ if (size1 < std_page_size) { size1 = std_page_size; } \ {var uintL size2 = size1 + sizeof(NODE) + (varobject_alignment-1); \ var aint addr = (aint)mymalloc(size2); \ @@ -455,7 +457,7 @@ var Pages page = (Pages)addr; \ page->m_start = addr; page->m_length = size2; \ # initialize: \ - page->page_start = page->page_end = page_start0(page); \ + page->page_start = page->page_end = page_start0(page) + misaligned; \ page->page_room = size1; \ # add to this heap: \ *pages_ptr = AVL(AVLID,insert1)(page,*pages_ptr); \ @@ -468,7 +470,7 @@ # try to get space from the operating system: #define make_space_using_malloc() \ do { \ - var uintL size1 = round_up(need,sizeof(cons_)); \ + var uintL size1 = round_up(misaligned+need,sizeof(cons_)); \ if (size1 < std_page_size) { size1 = std_page_size; } \ begin_system_call(); \ {var Pages page = (NODE*)malloc(sizeof(NODE)); \ @@ -480,7 +482,7 @@ # get page from the OS. \ page->m_start = addr; page->m_length = size2; \ # Initialize: \ - page->page_start = page->page_end = page_start0(page); \ + page->page_start = page->page_end = page_start0(page) + misaligned; \ page->page_room = size1; \ # add to this heap: \ *pages_ptr = AVL(AVLID,insert1)(page,*pages_ptr); \ @@ -493,14 +495,14 @@ } \ }}} while(0) #endif - if ((need <= std_page_size) && !(mem.free_pages == NULL)) { + if ((misaligned+need <= std_page_size) && !(mem.free_pages == NULL)) { # take a normal sized page from the common pool: var Pages page = mem.free_pages; mem.free_pages = (Pages)page->page_gcpriv.next; - # page is already correctly initialized: - # page->page_start = page->page_end = page_start0(page); + # page is already partially correctly initialized: # page->page_room = # round_down(page->m_start + page->m_length,varobject_alignment) + page->page_start = page->page_end = page_start0(page) + misaligned; # and add to this heap: *pages_ptr = AVL(AVLID,insert1)(page,*pages_ptr); if (!(AVL(AVLID,least)(need,pages_ptr,stack_ptr) == page)) Index: affi.d =================================================================== RCS file: /cvsroot/clisp/clisp/src/affi.d,v retrieving revision 1.28 retrieving revision 1.28.2.1 diff -u -d -r1.28 -r1.28.2.1 --- affi.d 16 Jan 2004 11:16:22 -0000 1.28 +++ affi.d 26 May 2004 14:59:28 -0000 1.28.2.1 @@ -779,12 +779,24 @@ uintC module__affi__subr_tab_size = subr_anz; -subr_ module__affi__subr_tab[subr_anz] = { - LISPFUN(affi_libcall,seclass_default,2,0,rest,nokey,0,NIL) - LISPFUN(mem_read,seclass_default,2,1,norest,nokey,0,NIL) - LISPFUN(mem_write,seclass_default,3,1,norest,nokey,0,NIL) - LISPFUN(mem_write_vector,seclass_default,2,1,norest,nokey,0,NIL) - LISPFUN(affi_nonzerop,seclass_default,1,0,norest,nokey,0,NIL) +struct { + VAROBJECTS_ALIGNMENT_DUMMY_DECL + subr_t subrs[subr_anz]; +} module__affi__subr_tab + #if defined(HEAPCODES) && (alignment_long < varobject_alignment) && defined(GNU) + __attribute__ ((aligned (varobject_alignment))) + #endif + = { + #if varobjects_misaligned + { 0 }, + #endif + { + LISPFUN(affi_libcall,seclass_default,2,0,rest,nokey,0,NIL) + LISPFUN(mem_read,seclass_default,2,1,norest,nokey,0,NIL) + LISPFUN(mem_write,seclass_default,3,1,norest,nokey,0,NIL) + LISPFUN(mem_write_vector,seclass_default,2,1,norest,nokey,0,NIL) + LISPFUN(affi_nonzerop,seclass_default,1,0,norest,nokey,0,NIL) + } }; subr_initdata_t module__affi__subr_tab_initdata[subr_anz] = { Index: ChangeLog =================================================================== RCS file: /cvsroot/clisp/clisp/src/ChangeLog,v retrieving revision 1.2750.2.40 retrieving revision 1.2750.2.41 diff -u -d -r1.2750.2.40 -r1.2750.2.41 --- ChangeLog 26 May 2004 14:50:05 -0000 1.2750.2.40 +++ ChangeLog 26 May 2004 14:59:28 -0000 1.2750.2.41 @@ -1,3 +1,65 @@ +2004-05-23 Bruno Haible <br...@cl...> + + * spvw_allocate.d (make_space_gc) [SPVW_BLOCKS]: Take + varobjects_misaligned into account. + * spvw_memfile.d (loadmem_from_handle): Take varobjects_misaligned into + account. + +2004-05-21 Bruno Haible <br...@cl...> + + Make it possible to enforce an alignment == 4 mod 8 of all varobjects + in HEAPCODES mode. + * lispbibl.d (varobjects_misaligned, VAROBJECTS_ALIGNMENT_DUMMY_DECL): + New macros. + (conses_misaligned): New macro. + (subr_t): Check that the size is a multiple of varobject_alignment. + (DYNAMIC_8BIT_VECTOR, DYNAMIC_STRING): Enforce varobjects_misaligned. + (subr_tab_, symbol_tab_): Add a varobjects_misaligned dummy decl. + * genclisph.d (main): Emit varobjects_misaligned, + VAROBJECTS_ALIGNMENT_DUMMY_DECL, varobject_alignment definitions. + Update subr_tab_, symbol_tab_ definitions. + * spvw.d (subr_anz, symbol_anz): Take varobjects_misaligned into + account. + (for_all_subrs, for_all_constsyms): Likewise. + (init_subr_tab_1, init_symbol_tab_1, init_symbol_tab_2): Likewise. + (init_symbol_functions): Likewise. + (main): Likewise. Let heap_start point past the misaligned bytes. + If SINGLEMAP_MEMORY || TRIVIALMAP_MEMORY, preallocate the first heap + page. If SPVW_PAGES, initialize heap->misaligned. + (dynload_modules): Take varobjects_misaligned into account. + * spvw_heap.d (Heap) [SPVW_PAGES]: Add misaligned field. + * spvw_global.d (check_gc_consistency): Take varobjects_misaligned into + account. + * spvw_garcol.d (gar_col_normal): If GENERATIONAL_GC, let generation 1 + respect varobjects_misaligned. + (gc_compact_heap): Don't set a page's page_start and page_end before + it is moved to the free_pages pool. + * spvw_genera1.d (build_old_generation_cache): Allow for the + possibility that heap_gen0_start has varobjects_misaligned. + * spvw_allocate.d (make_space_gc_true): Take varobjects_misaligned into + account. + (make_space_gc_false): Assume map_pagesize is a power of 2. + (make_space_gc) [SPVW_PAGES]: Take a Heap* as argument, not a Pages*. + Take varobjects_misaligned into account. Set a page's page_start and + page_end when taking it from the free_pages pool. + (make_space) [SPVW_PAGES]: Update. + * spvw_memfile.d (WRITE_page_alignment, READ_page_alignment): Add + parens where needed. + (savemem): Write out zero-bytes to enforce the varobjects_misaligned. + (loadmem_from_handle): Take varobjects_misaligned into account. + If SINGLEMAP_MEMORY || TRIVIALMAP_MEMORY, mmap also the zero-bytes + that enforce the varobjects_misaligned. + * spvwtabf.d (subr_tab_data): Enforce varobject_alignment. Add + varobjects_misaligned dummy bytes at the beginning. + (subr_tab_data_size): Take varobjects_misaligned into account. + * spvwtabs.d (symbol_tab_data): Enforce varobject_alignment. Add + varobjects_misaligned dummy bytes at the beginning. + * modules.d (MODULE, modules): Add the varobjects_misaligned bytes at + the beginning of the module's subr_tab. + * affi.d (module__affi__subr_tab): Likewise. + * utils/modprep.lisp (print-tables-1, print-tables-2): Likewise. + * utils/modpreptest.out: Update. + 2004-05-18 Bruno Haible <br...@cl...> * lispbibl.d (number_immediatep): New macro. Index: spvwtabf.d =================================================================== RCS file: /cvsroot/clisp/clisp/src/spvwtabf.d,v retrieving revision 1.4 retrieving revision 1.4.2.1 diff -u -d -r1.4 -r1.4.2.1 --- spvwtabf.d 14 Jun 2002 15:42:50 -0000 1.4 +++ spvwtabf.d 26 May 2004 14:59:27 -0000 1.4.2.1 @@ -1,6 +1,6 @@ # Moved out of memory management: # table of all SUBRs -# Bruno Haible 1990-1999 +# Bruno Haible 1990-2004 #include "lispbibl.c" @@ -8,8 +8,15 @@ # table of all SUBRs global struct subr_tab_ subr_tab_data - #if defined(INIT_SUBR_TAB) + #if defined(HEAPCODES) && (alignment_long < varobject_alignment) && defined(GNU) + # Force all Subrs to be allocated with a 4/8-byte alignment. GC needs this. + __attribute__ ((aligned (varobject_alignment))) + #endif + #if defined(INIT_SUBR_TAB) = { + #if varobjects_misaligned + { 0 }, + #endif #if NIL_IS_CONSTANT #define LISPFUN LISPFUN_G #else @@ -18,7 +25,7 @@ #include "subr.c" #undef LISPFUN } - #endif - ; -global uintC subr_tab_data_size = sizeof(subr_tab_data)/sizeof(subr_t); + #endif + ; +global uintC subr_tab_data_size = (sizeof(subr_tab_data)-varobjects_misaligned)/sizeof(subr_t); Index: spvw_global.d =================================================================== RCS file: /cvsroot/clisp/clisp/src/spvw_global.d,v retrieving revision 1.12 retrieving revision 1.12.2.1 diff -u -d -r1.12 -r1.12.2.1 --- spvw_global.d 27 Oct 2003 12:42:59 -0000 1.12 +++ spvw_global.d 26 May 2004 14:59:28 -0000 1.12.2.1 @@ -292,7 +292,7 @@ if ((sintL)page->page_room < 0) { fprintf(stderr,"\npage overrun at address 0x%x\n",page); abort(); } - if (page->page_start != page_start0(page)) { + if (page->page_start != page_start0(page) + mem.heaps[heapnr].misaligned) { fprintf(stderr,"\ninconsistent page at address 0x%x\n",page); abort(); } Index: spvw_heap.d =================================================================== RCS file: /cvsroot/clisp/clisp/src/spvw_heap.d,v retrieving revision 1.9 retrieving revision 1.9.2.1 diff -u -d -r1.9 -r1.9.2.1 --- spvw_heap.d 27 Oct 2003 12:26:24 -0000 1.9 +++ spvw_heap.d 26 May 2004 14:59:28 -0000 1.9.2.1 @@ -24,6 +24,7 @@ # _Page reserve; # a reserve-page ?? # heap for objects of fixed length: Pages lastused; # a cache for the last used page + uintL misaligned; # a misalignment that must be applied to all objects } Heap; #define map_heap(heap,pagevar,statement) \ @@ -106,7 +107,8 @@ # reaches until heap_gen0_end. # the generation 1 (newer generation) begins at heap_gen1_start, # reaches until heap_end. -# heap_gen0_start and heap_gen1_start are divisible by physpagesize. +# heap_gen0_start and heap_gen1_start are divisible by physpagesize or +# (for mem.varobjects) == varobjects_misaligned mod physpagesize. # Between heap_gen0_end and heap_gen1_start is a gap of # less than a page. # heap_start is either = heap_gen0_start or = heap_gen1_start. @@ -116,7 +118,8 @@ # For mem.varobjects: # generation 1 (newer generation) begins at heap_gen1_start, # reaches until heap_end. -# heap_gen0_start and heap_gen1_start are divisible by physpagesize. +# heap_gen0_start and heap_gen1_start are divisible by physpagesize or +# == varobjects_misaligned mod physpagesize. # Between heap_gen0_end and heap_gen1_start is a gap of # less than a page. # heap_start is either = heap_gen0_start or = heap_gen1_start. Index: spvwtabs.d =================================================================== RCS file: /cvsroot/clisp/clisp/src/spvwtabs.d,v retrieving revision 1.6 retrieving revision 1.6.2.1 diff -u -d -r1.6 -r1.6.2.1 --- spvwtabs.d 1 Mar 2004 11:12:05 -0000 1.6 +++ spvwtabs.d 26 May 2004 14:59:27 -0000 1.6.2.1 @@ -23,12 +23,19 @@ /* Table of all fixed symbols: */ global struct symbol_tab_ symbol_tab_data - #if defined(INIT_SYMBOL_TAB) && NIL_IS_CONSTANT - = { - #define LISPSYM LISPSYM_B - #include "constsym.c" - #undef LISPSYM - } - #endif + #if defined(HEAPCODES) && (alignment_long < varobject_alignment) && defined(GNU) + # Force all symbols to be allocated with a 4/8-byte alignment. GC needs this. + __attribute__ ((aligned (varobject_alignment))) + #endif + #if defined(INIT_SYMBOL_TAB) && NIL_IS_CONSTANT + = { + #if varobjects_misaligned + { 0 }, + #endif + #define LISPSYM LISPSYM_B + #include "constsym.c" + #undef LISPSYM + } + #endif ; Index: spvw_garcol.d =================================================================== RCS file: /cvsroot/clisp/clisp/src/spvw_garcol.d,v retrieving revision 1.61.2.1 retrieving revision 1.61.2.2 diff -u -d -r1.61.2.1 -r1.61.2.2 --- spvw_garcol.d 26 May 2004 14:48:55 -0000 1.61.2.1 +++ spvw_garcol.d 26 May 2004 14:59:27 -0000 1.61.2.2 @@ -2072,6 +2072,10 @@ var aint end = heap->heap_end; heap->heap_gen0_end = end; end = (end + (physpagesize-1)) & -physpagesize; + #if varobjects_misaligned + if (is_varobject_heap(heapnr)) + end += varobjects_misaligned; + #endif heap->heap_gen1_start = heap->heap_end = end; } build_old_generation_cache(heapnr); @@ -2466,8 +2470,7 @@ free_page_later(page); # return to OS later } else { # normal large page - # initialize again (page->page_room remains the same!): - page->page_start = page->page_end = page_start0(page); + # keep; page->page_room remains the same! # insert into the pool mem.free_pages: page->page_gcpriv.next = mem.free_pages; mem.free_pages = page; Index: lispbibl.d =================================================================== RCS file: /cvsroot/clisp/clisp/src/lispbibl.d,v retrieving revision 1.435.2.11 retrieving revision 1.435.2.12 diff -u -d -r1.435.2.11 -r1.435.2.12 --- lispbibl.d 26 May 2004 14:50:03 -0000 1.435.2.11 +++ lispbibl.d 26 May 2004 14:59:16 -0000 1.435.2.12 @@ -3038,6 +3038,21 @@ #endif # TYPECODES +# The misalignment of varobjects, modulo varobject_alignment. +#ifndef varobjects_misaligned + #define varobjects_misaligned 0 +#endif +#if varobjects_misaligned + #define VAROBJECTS_ALIGNMENT_DUMMY_DECL char alignment_dummy[varobjects_misaligned]; +#else + #define VAROBJECTS_ALIGNMENT_DUMMY_DECL +#endif + +# The misalignment of conses, modulo 2*sizeof(gcv_object_t). +#ifndef conses_misaligned + #define conses_misaligned 0 +#endif + # Objects with variable length must reside at addresses that are divisable by 2 #if defined(VAX) # ?? gcc/config/vax/vax.h sagt: Alignment = 4 @@ -5272,6 +5287,8 @@ uintB key_flag; # flag for keywords uintW key_anz; # number of keyword parameter uintW seclass; /* side-effect class */ + # If necessary, add fillers here to ensure sizeof(subr_t) is a multiple of + # varobject_alignment. } subr_t #if defined(HEAPCODES) && (alignment_long < 4) && defined(GNU) # Force all Subrs to be allocated with a 4-byte alignment. GC needs this. @@ -5279,6 +5296,8 @@ #endif ; typedef subr_t * Subr; + # Compile-time check: sizeof(subr_t) is a multiple of varobject_alignment. + typedef int subr_size_check[1 - 2 * (sizeof(subr_t) % varobject_alignment)]; # GC needs information where objects are in here: #define subr_length 2 #define subr_xlength (sizeof(*(Subr)0)-offsetofa(record_,recdata)-subr_length*sizeof(gcv_object_t)) @@ -7824,9 +7843,10 @@ ((Sbvector)objvar##_storage)->length = (len) #else #define DYNAMIC_8BIT_VECTOR(objvar,len) \ - DYNAMIC_ARRAY(objvar##_storage,object,ceiling((uintL)(len)+offsetofa(sbvector_,data),sizeof(gcv_object_t))); \ - var object objvar = ((Sbvector)objvar##_storage)->GCself = bias_type_pointer_object(varobject_bias,sb8vector_type,(Sbvector)objvar##_storage); \ - ((Sbvector)objvar##_storage)->tfl = lrecord_tfl(Rectype_Sb8vector,len) + DYNAMIC_ARRAY(objvar##_storage,object,ceiling((uintL)(len)+offsetofa(sbvector_,data)+varobjects_misaligned,sizeof(gcv_object_t))); \ + var object* objvar##_address = (object*)((uintP)objvar##_storage | varobjects_misaligned); \ + var object objvar = ((Sbvector)objvar##_address)->GCself = bias_type_pointer_object(varobject_bias,sb8vector_type,(Sbvector)objvar##_address); \ + ((Sbvector)objvar##_address)->tfl = lrecord_tfl(Rectype_Sb8vector,len) #endif #define FREE_DYNAMIC_8BIT_VECTOR(objvar) \ FREE_DYNAMIC_ARRAY(objvar##_storage) @@ -7939,14 +7959,16 @@ #else #ifdef UNICODE #define DYNAMIC_STRING(objvar,len) \ - DYNAMIC_ARRAY(objvar##_storage,object,ceiling((uintL)(len)*sizeof(chart)+offsetofa(sstring_,data),sizeof(gcv_object_t))); \ - var object objvar = ((Sstring)objvar##_storage)->GCself = bias_type_pointer_object(varobject_bias,sstring_type,(Sstring)objvar##_storage); \ - ((Sstring)objvar##_storage)->tfl = lrecord_tfl(Rectype_S32string,len); + DYNAMIC_ARRAY(objvar##_storage,object,ceiling((uintL)(len)*sizeof(chart)+offsetofa(sstring_,data)+varobjects_misaligned,sizeof(gcv_object_t))); \ + var object* objvar##_address = (object*)((uintP)objvar##_storage | varobjects_misaligned); \ + var object objvar = ((Sstring)objvar##_address)->GCself = bias_type_pointer_object(varobject_bias,sstring_type,(Sstring)objvar##_address); \ + ((Sstring)objvar##_address)->tfl = lrecord_tfl(Rectype_S32string,len); #else #define DYNAMIC_STRING(objvar,len) \ - DYNAMIC_ARRAY(objvar##_storage,object,ceiling((uintL)(len)*sizeof(chart)+offsetofa(sstring_,data),sizeof(gcv_object_t))); \ - var object objvar = ((Sstring)objvar##_storage)->GCself = bias_type_pointer_object(varobject_bias,sstring_type,(Sstring)objvar##_storage); \ - ((Sstring)objvar##_storage)->tfl = lrecord_tfl(Rectype_S8string,len); + DYNAMIC_ARRAY(objvar##_storage,object,ceiling((uintL)(len)*sizeof(chart)+offsetofa(sstring_,data)+varobjects_misaligned,sizeof(gcv_object_t))); \ + var object* objvar##_address = (object*)((uintP)objvar##_storage | varobjects_misaligned); \ + var object objvar = ((Sstring)objvar##_address)->GCself = bias_type_pointer_object(varobject_bias,sstring_type,(Sstring)objvar##_address); \ + ((Sstring)objvar##_address)->tfl = lrecord_tfl(Rectype_S8string,len); #endif #endif #define FREE_DYNAMIC_STRING(objvar) \ @@ -8615,6 +8637,7 @@ # Make Subr-tables visible: #define LISPFUN LISPFUN_C extern struct subr_tab_ { + VAROBJECTS_ALIGNMENT_DUMMY_DECL #include "subr.c" } subr_tab_data; #undef LISPFUN @@ -8678,6 +8701,7 @@ # Declaration if the Symbol-table: #define LISPSYM LISPSYM_A extern struct symbol_tab_ { + VAROBJECTS_ALIGNMENT_DUMMY_DECL #include "constsym.c" } symbol_tab_data; #undef LISPSYM Index: genclisph.d =================================================================== RCS file: /cvsroot/clisp/clisp/src/genclisph.d,v retrieving revision 1.99.2.7 retrieving revision 1.99.2.8 diff -u -d -r1.99.2.7 -r1.99.2.8 --- genclisph.d 26 May 2004 14:48:56 -0000 1.99.2.7 +++ genclisph.d 26 May 2004 14:59:27 -0000 1.99.2.8 @@ -684,6 +684,13 @@ printf("#define gcinvariant_object_p(obj) (((as_oint(obj) & 1) == 0) || immediate_object_p(obj))\n"); printf("#define gcinvariant_bias_p(bias) ((((bias) & 1) == 0) || ((7 & ~(bias)) == 0))\n"); #endif + printf1("#define varobjects_misaligned %d\n",varobjects_misaligned); +#if varobjects_misaligned + printf1("#define VAROBJECTS_ALIGNMENT_DUMMY_DECL char alignment_dummy[%d];\n",varobjects_misaligned); +#else + printf("#define VAROBJECTS_ALIGNMENT_DUMMY_DECL\n"); +#endif + printf1("#define varobject_alignment %d\n",varobject_alignment); #ifdef DEBUG_GCSAFETY printf("static inline bool gcinvariant_symbol_p (object obj);\n"); printf("inline gcv_object_t::operator object () const { return (object){ one_o: one_o, allocstamp: alloccount }; }\n"); @@ -1399,6 +1406,7 @@ emit_typedef_f("Values %s(void)","subr_norest_function_t"); emit_typedef_f("Values %s(uintC argcount, object* rest_args_pointer)","subr_rest_function_t"); */ printf("extern struct subr_tab_ {\n"); + printf(" VAROBJECTS_ALIGNMENT_DUMMY_DECL\n"); #undef LISPFUN #define LISPFUN(name,sec,req_anz,opt_anz,rest_flag,key_flag,key_anz,keywords) \ printf(" subr_t %s;\n",STRING(D_##name)); @@ -1426,6 +1434,7 @@ printf("#define L(name) subr_tab_ptr_as_object(&subr_tab_addr->D_##name)\n"); #endif printf("extern struct symbol_tab_ {\n"); + printf(" VAROBJECTS_ALIGNMENT_DUMMY_DECL\n"); #define LISPSYM(name,printname,package) \ printf(" symbol_ %s;\n",STRING(S_##name)); #include "constsym.c" Index: spvw.d =================================================================== RCS file: /cvsroot/clisp/clisp/src/spvw.d,v retrieving revision 1.267.2.2 retrieving revision 1.267.2.3 diff -u -d -r1.267.2.2 -r1.267.2.3 --- spvw.d 26 May 2004 14:48:54 -0000 1.267.2.2 +++ spvw.d 26 May 2004 14:59:27 -0000 1.267.2.3 @@ -37,7 +37,7 @@ # table of all SUBRs: out-sourced to SPVWTABF # size of this table: -#define subr_anz (sizeof(subr_tab)/sizeof(subr_t)) +#define subr_anz ((sizeof(subr_tab)-varobjects_misaligned)/sizeof(subr_t)) # table of all FSUBRs: moved to CONTROL # size of this table: @@ -57,7 +57,7 @@ # table of all fixed symbols: moved to SPVWTABS # size of these tables: -#define symbol_anz (sizeof(symbol_tab)/sizeof(symbol_)) +#define symbol_anz ((sizeof(symbol_tab)-varobjects_misaligned)/sizeof(symbol_)) # table of all other fixed objects: moved to SPVWTABO # size of these tables: @@ -68,22 +68,25 @@ # into a genuine lisp-object.) #ifdef MAP_MEMORY_TABLES local uintC total_subr_anz; - #define for_all_subrs(statement) \ - do { var subr_t* ptr = (subr_t*)&subr_tab; /* traverse subr_tab */ \ - var uintC count; \ - dotimesC(count,total_subr_anz, { statement; ptr++; } ); \ + #define for_all_subrs(statement) \ + do { \ + var subr_t* ptr = (subr_t*)((char*)&subr_tab+varobjects_misaligned); /* traverse subr_tab */ \ + var uintC count; \ + dotimesC(count,total_subr_anz, { statement; ptr++; } ); \ } while(0) #else - #define for_all_subrs(statement) \ - do { var module_t* module; /* traverse modules */ \ - for_modules(all_modules,{ \ - if (module->initialized) \ - if (*module->stab_size > 0) { \ - var subr_t* ptr = module->stab; \ - var uintC count; \ - dotimespC(count,*module->stab_size, \ - { statement; ptr++; } ); \ - }}); \ + #define for_all_subrs(statement) \ + do { \ + var module_t* module; /* traverse modules */ \ + for_modules(all_modules,{ \ + if (module->initialized) \ + if (*module->stab_size > 0) { \ + var subr_t* ptr = module->stab; \ + var uintC count; \ + dotimespC(count,*module->stab_size, \ + { statement; ptr++; } ); \ + } \ + }); \ } while(0) #endif @@ -104,7 +107,7 @@ #endif # traversal of symbol_tab: #define for_all_constsyms(statement) \ - do { var symbol_* ptr = (symbol_*)&symbol_tab; # pass through symbol_tab \ + do { var symbol_* ptr = (symbol_*)((char*)&symbol_tab+varobjects_misaligned); # pass through symbol_tab \ var uintC count; \ dotimesC(count,symbol_anz, { statement; ptr++; } ); \ } while(0) @@ -865,14 +868,14 @@ #endif #if !NIL_IS_CONSTANT { # initialize the name-slot first: - var subr_t* ptr = (subr_t*)&subr_tab; # traverse subr_tab + var subr_t* ptr = (subr_t*)((char*)&subr_tab+varobjects_misaligned); # traverse subr_tab #define LISPFUN LISPFUN_E #include "subr.c" #undef LISPFUN } { # and initialize the GCself and keywords-slot temporarily: - var subr_t* ptr = (subr_t*)&subr_tab; # traverse subr_tab - var uintC count = subr_anz; + var subr_t* ptr = (subr_t*)((char*)&subr_tab+varobjects_misaligned); # traverse subr_tab + var uintC count; dotimesC(count,subr_anz, { ptr->GCself = subr_tab_ptr_as_object(ptr); ptr->keywords = NIL; @@ -883,13 +886,13 @@ # Because of SPVWTABF all slots except keywords and argtype # are already initialized. { # now initialize the argtype-slot: - var subr_t* ptr = (subr_t*)&subr_tab; # traverse subr_tab + var subr_t* ptr = (subr_t*)((char*)&subr_tab+varobjects_misaligned); # traverse subr_tab var uintC count; dotimesC(count,subr_anz,{ SUBR_SET_ARGTYPE(ptr,NULL); ptr++; }); } #else { # initialize all slots except keywords: - var subr_t* ptr = (subr_t*)&subr_tab; # traverse subr_tab + var subr_t* ptr = (subr_t*)((char*)&subr_tab+varobjects_misaligned); # traverse subr_tab #define LISPFUN LISPFUN_D #include "subr.c" #undef LISPFUN @@ -903,7 +906,7 @@ } #ifdef MAP_MEMORY_TABLES { # ditto, copy other tables tino the mapped region: - var subr_t* newptr = (subr_t*)&subr_tab; + var subr_t* newptr = (subr_t*)((char*)&subr_tab+varobjects_misaligned); var module_t* module; main_module.stab = newptr; newptr += subr_anz; for_modules(all_other_modules,{ @@ -914,7 +917,7 @@ dotimespC(count,*module->stab_size, { *newptr++ = *oldptr++; } ); } }); - ASSERT(newptr == (subr_t*)&subr_tab + total_subr_anz); + ASSERT(newptr == (subr_t*)((char*)&subr_tab+varobjects_misaligned) + total_subr_anz); } #endif } @@ -927,7 +930,7 @@ #endif #else { - var symbol_* ptr = (symbol_*)&symbol_tab; # traverse symbol_tab + var symbol_* ptr = (symbol_*)((char*)&symbol_tab+varobjects_misaligned); # traverse symbol_tab var uintC count; for (count = symbol_anz; count > 0; count--) { ptr->GCself = symbol_tab_ptr_as_object(ptr); @@ -1055,7 +1058,7 @@ dotimespC(count,package_anz, { pushSTACK(Car(list)); list = Cdr(list); }); } { - var symbol_* ptr = (symbol_*)&symbol_tab; # traverse symbol_tab + var symbol_* ptr = (symbol_*)((char*)&symbol_tab+varobjects_misaligned); # traverse symbol_tab var const char * const * pname_ptr = &pname_table[0]; # traverse pname_table var const uintB* index_ptr = &package_index_table[0]; # traverse package_index_table var uintC count = symbol_anz; @@ -1122,7 +1125,7 @@ }); } { # enter SUBRs: - var subr_t* ptr = (subr_t*)&subr_tab; # traverse subr_tab + var subr_t* ptr = (subr_t*)((char*)&subr_tab+varobjects_misaligned); # traverse subr_tab var uintC count; dotimesC(count,subr_anz,{ Symbol_function(ptr->name) = subr_tab_ptr_as_object(ptr); @@ -2315,7 +2318,7 @@ multimap(case_symbolflagged: , 0, memneed, false); } # set subr_tab to address 0: - if (zeromap(&subr_tab,round_up(total_subr_anz*sizeof(subr_t),pagesize)) <0) + if (zeromap(&subr_tab,round_up(varobjects_misaligned+total_subr_anz*sizeof(subr_t),pagesize)) <0) goto no_mem; #else # multimap symbol_tab and subr_tab: @@ -2365,7 +2368,7 @@ mem.heaps[typecode(as_object((oint)&tab))].heap_limit += map_len; \ } while(0) map_tab(symbol_tab,sizeof(symbol_tab)); - map_tab(subr_tab,total_subr_anz*sizeof(subr_t)); + map_tab(subr_tab,varobjects_misaligned+total_subr_anz*sizeof(subr_t)); #endif #ifdef TRIVIALMAP_MEMORY # initialize all heaps as empty. @@ -2436,7 +2439,15 @@ var uintL heapnr; for (heapnr=0; heapnr<heapcount; heapnr++) { var Heap* heapptr = &mem.heaps[heapnr]; - heapptr->heap_start = heapptr->heap_end = heapptr->heap_limit; + heapptr->heap_start = heapptr->heap_limit; + #if varobjects_misaligned + if (is_varobject_heap(heapnr)) { + if (zeromap((void*)heapptr->heap_start,map_pagesize) < 0) goto no_mem; + heapptr->heap_limit = heapptr->heap_start + map_pagesize; + heapptr->heap_start += varobjects_misaligned; + } + #endif + heapptr->heap_end = heapptr->heap_start; #ifdef SELFMADE_MMAP heapptr->memfile_numpages = 0; # heapptr->memfile_pages = NULL; # irrelevant @@ -2444,7 +2455,7 @@ #endif #ifdef GENERATIONAL_GC heapptr->heap_gen0_start = heapptr->heap_gen0_end = - heapptr->heap_gen1_start = heapptr->heap_limit; + heapptr->heap_gen1_start = heapptr->heap_start; heapptr->physpages = NULL; #endif } @@ -2574,9 +2585,9 @@ #ifdef GENERATIONAL_GC mem.varobjects.heap_gen0_start = mem.varobjects.heap_gen0_end = mem.varobjects.heap_gen1_start = mem.varobjects.heap_start = - (ptr + (physpagesize-1)) & -physpagesize; + ((ptr + (physpagesize-1)) & -physpagesize) + varobjects_misaligned; #else - mem.varobjects.heap_start = ptr; + mem.varobjects.heap_start = ptr + varobjects_misaligned; #endif mem.varobjects.heap_end = mem.varobjects.heap_start; # there are no objects of variable length, yet # rest (14/16 or a little less) for lisp-objects: @@ -2608,6 +2619,8 @@ for_each_heap(heap, { heap->inuse = EMPTY; } ); for_each_cons_heap(heap, { heap->lastused = dummy_lastused; } ); dummy_lastused->page_room = 0; + for_each_varobject_heap(heap, { heap->misaligned = varobjects_misaligned; } ); + for_each_cons_heap(heap, { heap->misaligned = conses_misaligned; } ); mem.free_pages = NULL; mem.total_space = 0; mem.used_space = 0; @@ -3142,7 +3155,7 @@ } { # Find the addresses of some C data in the shared library: sprintf(symbolbuf,"module__%s__subr_tab",modname); - module->stab = (subr_t*) dlsym(libhandle,symbolbuf); + module->stab = (subr_t*) ((char*) dlsym(libhandle,symbolbuf) + varobjects_misaligned); err = dlerror(); if (err) fehler_dlerror("dlsym",symbolbuf,err); } @@ -3208,12 +3221,12 @@ if (*module->stab_size > 0) module_set_argtypes(module); #if (defined(MULTIMAP_MEMORY) || defined(SINGLEMAP_MEMORY)) && defined(MAP_MEMORY_TABLES) { - var subr_t* newptr = (subr_t*)&subr_tab + total_subr_anz; + var subr_t* newptr = (subr_t*)((char*)&subr_tab+varobjects_misaligned) + total_subr_anz; var uintC count = *module->stab_size; if (count > 0) { { - var uintL old_map_len = round_up(total_subr_anz*sizeof(subr_t),map_pagesize); - var uintL new_map_len = round_up((total_subr_anz+count)*sizeof(subr_t),map_pagesize); + var uintL old_map_len = round_up(varobjects_misaligned+total_subr_anz*sizeof(subr_t),map_pagesize); + var uintL new_map_len = round_up(varobjects_misaligned+(total_subr_anz+count)*sizeof(subr_t),map_pagesize); if (old_map_len < new_map_len) { if (zeromap((void*)((aint)&subr_tab+old_map_len),new_map_len-old_map_len) <0) fehler_dlerror("zeromap",NULL,"out of memory for subr_tab"); --__--__-- _______________________________________________ clisp-cvs mailing list cli...@li... https://lists.sourceforge.net/lists/listinfo/clisp-cvs End of clisp-cvs Digest |