[9fans] ainc() 386/amd64 differences

[9fans] ainc() 386/amd64 differences

[erik quanstrom]

for 386, libc has this definition for ainc

TEXT ainc(SB), $0	/* int ainc(int *); */
	MOVL	addr+0(FP), BX
ainclp:
	MOVL	(BX), AX
	MOVL	AX, CX
	INCL	CX
	LOCK
	BYTE	$0x0F; BYTE $0xB1; BYTE $0x0B	/* CMPXCHGL CX, (BX) */
	JNZ	ainclp
	MOVL	CX, AX
	RET

the amd64 kernel has had this definition (the pc kernel doesn't define ainc)

TEXT ainc(SB), 1, $-4
	MOVL	$1, AX
	LOCK; XADDL AX, (RARG)
	ADDL	$1, AX				/* overflow if -ve or 0 */
	JGT	_return
_trap:
	XORQ	BX, BX
	MOVQ	(BX), BX			/* over under sideways down */
_return:
	RET

these are substantially different in two ways.
- the first is not wait free.  the second may be wait free.
- the second is geared toward reference counting, and will
trap instead of wrapping.  it can't be used for generating
a unique sequence.

i'd like to see the amd64 kernel version replace incref, and
this version of ainc

TEXT ainc(SB), 1, $-4
TEXT ainc32(SB), 1, $-4
	MOVL	$1, AX
	LOCK; XADDL AX, (RARG)
	INCL	AX
	RET

what does the list think?

- erik

Re: [9fans] ainc() 386/amd64 differences

[Charles Forsyth]

[-- Attachment #1: Type: text/plain, Size: 364 bytes --]

% cat ../port/ref.c
#include "u.h"
#include "../port/lib.h"
#include "mem.h"
#include "dat.h"
#include "fns.h"

int
incref(Ref *r)
{
int x;

x = ainc(&r->ref);
if(x <= 0)
panic("incref pc=%#p", getcallerpc(&r));
return x;
}

int
decref(Ref *r)
{
int x;

x = adec(&r->ref);
if(x < 0)
panic("decref pc=%#p", getcallerpc(&r));
return x;
}

[-- Attachment #2: Type: text/html, Size: 2116 bytes --]

Re: [9fans] ainc() 386/amd64 differences

[erik quanstrom]

> int
> incref(Ref *r)
> {
> int x;
>
> x = ainc(&r->ref);
> if(x <= 0)
> panic("incref pc=%#p", getcallerpc(&r));
> return x;
> }

ah, yes.  i'd not remembered this nice implementation.

then your ainc is guard-free?  and your Ref is struct Ref {int ref;}?
also, did you decide that any reuse of the ref lock is already buggy and needs
no further review?  that's the bit i got bogged down on.

- erik

Re: [9fans] ainc() 386/amd64 differences

[erik quanstrom]

On Wed May 14 17:27:58 EDT 2014, quanstro@quanstro.net wrote:
> > int
> > incref(Ref *r)
> > {
> > int x;
> >
> > x = ainc(&r->ref);
> > if(x <= 0)
> > panic("incref pc=%#p", getcallerpc(&r));
> > return x;
> > }
>
> ah, yes.  i'd not remembered this nice implementation.
>
> then your ainc is guard-free?  and your Ref is struct Ref {int ref;}?
> also, did you decide that any reuse of the ref lock is already buggy and needs
> no further review?  that's the bit i got bogged down on.

i've rebooted my kernel with this change, and it appears to be solid.
still a bit concerned about additional consistency forced by the prior
incref.

- erik