Henrik you amaze me :) Stef Le 9/6/15 14:59, Henrik Johansen a écrit :
There are many ways to Rome :) If you just need some externally allocated objects in the formats you specified you can do the cache extraction using nothing but normal Smalltalk:
intArray := (NBExternalArray ofType: 'int').
data := intArray new: 1000. 1 to:data size do:[:i |data at:i put: i]. cache := intArray new: 50. 0 to: 4 do: [:j | 1 to: 10 do: [ :k | cache at: (j* 10) + k put: (data at: 199 + (30 * j ) + k)] ].
But if you want to take full advantage of the performance boost NB offers, you'd write a NativeBoost function to do the cache extraction*, as I outlined last time: MyClass class >> #createCacheOf: aSource in: aDestination createCacheOf: aSource in: aDestination <primitive: #primitiveNativeCall module: #NativeBoostPlugin> "Should work on both x86 and x64, as long as sizeOf: lookups work correctly" ^ self nbCallout function: #(void (int * aSource, int * aDestination) ) emit: [:gen :proxy :asm | |destReg srcReg tmpReg intSize ptrSize| intSize := NBExternalType sizeOf: 'int'. ptrSize := NBExternalType sizeOf: 'void *'. "Only use caller-saved regs, no preservation needed" destReg := asm EAX as: ptrSize. srcReg := asm ECX as: ptrSize. tmpReg := asm EDX as: intSize. asm pop: srcReg. asm pop: destReg. 0 to: 4 do: [ :j | 0 to: 9 do: [ :offset | asm "Displacement in bytes, not ptr element size :S, so we have to multiply offset by that manually :S" mov: tmpReg with: srcReg ptr + (199 + (j * 30) + offset * intSize); mov: destReg ptr + ((j* 10) + offset * intSize) with: tmpReg]]]
and use that; intArray := (NBExternalArray ofType: 'int'). data := intArray new: 1000. 1 to:data size do:[:i |data at:i put: i]. cache := intArray new: 50. MyClass createCacheOf: data in: cache.
The difference using a simple [] bench is about two orders of magnitude; 11million cache extractions per seconds for the inline assembly version, while the naive loop achieves around 110k.
Cheers, Henry
*as: is not yet defined, could be something like: AJx86GPRegister >> #as: aSize ^ self isHighByte ifTrue: [ self asLowByte as: aSize ] ifFalse: [ AJx86Registers generalPurposeWithIndex: self index size: aSize requiresRex: self index > (aSize > 1 ifTrue: [7] ifFalse: [ 3]) prohibitsRex: false ]
On 09 Jun 2015, at 9:46 , Matthieu Lacaton <matthieu.lacaton@gmail.com <mailto:matthieu.lacaton@gmail.com>> wrote:
Hello Henrik,
Thank you very much for your answer. However, the code you provided is some sort of assembly right ? So does it mean that I need to learn assembly to do what I want ?
I'm asking that because I don't know anything about assembly so it will take me some time to learn.
Cheers,
Matthieu
2015-06-08 19:56 GMT+02:00 Henrik Johansen <henrik.s.johansen@veloxit.no <mailto:henrik.s.johansen@veloxit.no>>:
> On 08 Jun 2015, at 4:41 , Matthieu Lacaton <matthieu.lacaton@gmail.com <mailto:matthieu.lacaton@gmail.com>> wrote: > > Hello everyone, > > I have a small question about NativeBoost : How does the "+" operator when applied to a pointer translates into NativeBoost code ? > > To give a bit of context, what I want to do is to reallocate some non-contiguous bytes in memory to a buffer. Basically, I have an array of integers in a buffer and I want to copy some chunks of it in another buffer. The chunks are always the same size and the offset between each chunk is always the same too. > > Because a bit of actual code is easier to understand here is what I'd like to do in Pharo : > > ... > > int i, j; > int *data = malloc(1000*sizeof(int)); > int *newData = malloc(50*sizeof(int)); > > // Allocate initial data > for (i = 0 ; i < 1000, i++) { > data[i] = i; > } > > //Copy desired chunks into new buffer > for (i = 0; i < 5; i++ ) { > memcpy( newData + j*10, data + 200 + j*30, 10*sizeof(int)); > j++; > } > > free(data);
You can do relative addressing like this: (destReg ptr: dataSize) + offsetReg + constant
So with offSetRegs containing j* 10 and j* 30, you might end up with an unrolled inner loop (barring using any fancier longer-than-int moves) like:
0 to: 9 do: [:constantOffset | asm mov: (destReg ptr: currentPlatform sizeOfInt) + dstOffsetReg + constantOffset with: (srcReg ptr: currentPlatform sizeOfInt) + 200 + srcOffsetReg + constantOffset]
If the range of j is constant, you can just as easily unroll the whole thing in a similarly compact fashion, space and sensibilites permitting:
0 to: 4 do: [ :j | 0 to: 9 do: [ :consOffset | asm mov: (destReg ptr: currentPlatform sizeOfInt) + (j* 10) + constOffset with: (srcReg ptr: currentPlatform sizeOfInt) + 200 + (j * 30) + constOffset]
Cheers, Henry