libera/#clasp - IRC Chatlog
Search
20:43:13
Bike
if we didn't do that we would (as far as i have thought this through) need to keep track for each PC of what dynamic environments need to be unwound if we exit, so that we can have the C++ code unwind during an alien unwind
20:43:44
Bike
which is more or less how C++ unwinding works, except we'd be using bytecode pcs instead of machine
20:54:56
karlosz_
for non-local exits specifically (not unwind-protect) it would seem like you could just make C++ callouts save the current stack pointer before the call out and then on reutrn check the current stack pointer against the saved stack pointer
20:56:27
karlosz_
yeah, i guess we do need a frame then. but calling recursively shouldnt be a big deal
21:15:23
Bike
although if that's the case i wouldn't really expect recursive calls to work at all, so who knows
22:10:35
drmeister
Bike: (fib 30) was hanging the first time that I tried it - it could be for an unrelated reason such as we are blowing the side-stack. Is that possible yet?
22:11:16
drmeister
If it's not possible (we have 16K words at the moment) (fib 30) should only go like 30 levels deep - right?
22:29:58
Bike
karlosz: i thought i was going to need to use it in exit, which is why i asked about that
22:30:51
Bike
drmeister: should go 30 deep max, yeah... which is why i'm wondering if the stack pointer is being maintained improperly, so that each call leaves the stack pointer higher than it ought to be upon returning
22:36:07
drmeister
CL_DEFUN Integer_sp core__side_stack_pointer() { return Integer_O::create((uint64_t) my_thread->_VM._stackPointer);}
22:39:42
drmeister
Bike, karlosz: Can we avoid taking pointers to anything on the side stack? If we can then we can dynamically resize it.
22:40:23
drmeister
If we must take pointers, use indices relative to the bottom (stack grows up) of the stack.
23:23:33
Bike
drmeister: we use pointers into the stack as vaslists to calls, so no, we kind of can't avoid that (without having to copy everything for that stuff)
23:26:06
Bike
debugging the vm is very pleasant compared to debugging the machine target. i can have it just dump out every instruction no fuss, and we could dump the entire memory state (stack) too if we wanted
23:26:46
drmeister
The problem is down at the bottom GC_obj_kinds[k].ok_freelist[lg] -> 12 = (void *) 0xb9000055e48fbd77
23:27:07
Bike
i guess if the stack isn't maintained we could be using up all memory, which would probably do weird things to boehm
23:31:27
drmeister
Bike: I check the side stack pointer after each call from the command line. If there was creep - it should show up - right?
23:33:08
drmeister
Then I print the difference (- (core:side-stack-pointer) *sp*) whenever the argument to fib is 1.
23:35:59
Bike
wow i misread you. when you said the stack was being maintained properly i read the opposite. oops.
23:45:00
Bike
ok, so other things that could break boehm... well, the vm uses a law of untagged pointers, which is not something i usually do, so i might have screwed stuff up on that front
0:03:20
karlosz
drmeister: like Bike said, we do sort of want stack pointers in the VM instead of indices to keep things fast. for dynamically allocated stacks we could just create a new one twice as big and copy the whole thing and just updating the stack and frame pointer in the vm struct
0:04:25
drmeister
The side stack should be keeping things alive - I set the whole thing as a source of roots.
0:05:09
drmeister
It looks like we are writing garbage into the boehm memory. I see a tagged pointer being written into boehm memory.
0:07:24
drmeister
I'm using posix_memalign( &mem, pageSize, VirtualMachine::MaxStackWords*sizeof(T_O**) ); to allocate it
0:07:45
drmeister
And gctools::clasp_gc_registerRoots((this->_stackBottom),(this->_stackBytes-pageSize)/sizeof(T_O*)); to register the whole thing as a source of roots.
0:08:11
drmeister
I can't currently limit it just to the live stack. That's why I recommended that we stick NULL in each word as we pop words.
0:09:24
drmeister
Actually, there might be a way to limit what part of the side-stack is live. There are ways of making boehm just check a range of memory - but the last time I tried to use it it crashed.
0:09:59
karlosz
yeah... i guess that might potentially cause problems. i had thought that that would just mean keeping objects live at worst
0:10:04
drmeister
I think we need to add more checking to the VM. Check if writing to pointers are all aligned.
0:10:40
karlosz
but i suppose boehm won't like it if an object in the dead part of the stack gets overwritten by something else
0:19:33
karlosz
just fixed jump-if-supplied for variable length labels so lambda lists should work again
0:49:31
drmeister
I don't think garbage on the side-stack will hurt anything. Boehm is very, very tolerant
0:52:20
drmeister
I think it's more likely that we are writing into a tagged pointer or a tagged pointer when we should be writing an untagged one.
2:10:11
Bike
for the exit stuff i made a tiny little new structure VirtualMachineStackState that includes the frame pointer, and ENTRY uses it to restore the stack pointer after a nonlocal exit
2:10:29
Bike
could it like... get reclaimed wrongly by boehm somehow... i guess not, since fib doesn't even do nonlocal exits
2:15:38
Bike
maybe there's a size_t overflowing into a stupid high number, and that's ending up in push_frame or something
2:41:25
drmeister
I do say this though: static constexpr size_t MaxStackWords = 16384; // 16K words for now.
3:41:03
drmeister
I evaluate (fib 33) and print the stack for every instruction and there's no problem.
4:16:32
drmeister
I evaluate (fib 33) and the stack stays at 1000 bytes or so all the way except at the end it balloons.
5:28:33
drmeister
::notify Bike There is something deeply wrong. When I evaluate (fib 31) the evaluation goes off the rails at some point. So I'm trying to compile the following but the compiler isn't ready for it yet. I want to ID where it goes off the rails and then get udb in there to figure it out.
5:28:35
drmeister
(setf (fdefinition 'fib) (compile-to-vm::bcompile '(lambda (n cn) (setf (car cn) (+ (car cn) 1)) (format t "cn ~a~%" (car cn)) (if (eql n 1) 0 (if (eql n 2) 1 (+ (fib (- n 1) cn) (fib (- n 2) cn)))))))