Add code examples

[9prady9]

[polarathene]

Could an example(s) be added for those new to programming for GPU's? I've done a bit of OpenCL logic for adding an algorithm to the Hashcat project, but there was more freedom compared to how ArrayFire seems to restrict you to working with arrays?

// FNV-1a (32-bit) hashing algorithm
fn main() {
    let key = [0x68, 0x65, 0x6c, 0x6c, 0x6f]; // "hello"
    let mut hash: u32 = 2166136261; // Hash init value defined by algorithm

    for byte in key.iter() {
        hash ^= *byte as u32;
        hash *= 16777619; // Another magic number defined by the algorithm
    }

    println!("Hash is: {:x}", hash); // 4f9f2cab
}

Really simple code, take a string key as bytes and XOR them + multiply hash by a fixed value iteratively. With a large set of keys, how do you approach this in ArrayFire? Do you treat each key as a 1D array(column/ horizontal?) and rows of keys? If so does this mean I can only work on fixed string key lengths? hash would be used as a constant to fill another array for the operations?

This example would make me think that I should have an array for each letter position(5 in this case + 1 for the hash)? Also curious about optimizing/setting up the array and data right, no idea if 3rd/4th dimensions are helpful for this or row/column optimal sizes for performance, my actual algorithm is doing about 32 billion hashes a second with OpenCL and Hashcat, I'm wanting to see how ArrayFire compares.

---

I have a slightly more complicated hash algorithm to implement which starts with a while(length >= 24) operating on 24 bytes of the string key at a time for 3 64-bit unsigned integers. After that it handles the remaining <23 bytes a little differently. Both stages end with a call to an expensive function involving the 3 64-bit values being "mixed" with subtraction, XORing and bitshifting(both directions).

I can share C/OpenCL/Rust implementations I've done, if it'd be worthwhile how a fairly straightforward algorithm with loop/conditional/arithmitic diffs/ports to ArrayFire?

[polarathene]

I've had a try at porting the simple algorithm, wasn't too difficult with the one fixed key. Tried to add some dynamic strings and ran into memory issues somewhere between 625 and 3125 elements spread over 5 arrays. Code and discussion can be found on this Rust reddit post.

Any tips on what I'm doing wrong and could try? Or would ArrayFire not be the appropriate choice for this type of work on the GPU? I'm thinking I need to do the permutations via ArrayFire in GPU memory via some batching/loop?

[9prady9]

I think the variable hashes of type Array is incorrect. You are passing
in a slice of one value and passing in dims which seems to be a vector.

On Tue, Oct 18, 2016, 4:44 PM Brennan Kinney notifications@github.com
wrote:

I've had a try at porting the simple algorithm, wasn't too difficult with
the one fixed key. Tried to add some dynamic strings and ran into memory
issues somewhere between 625 and 3125 elements spread over 5 arrays. Code
and discussion can be found on this Rust reddit post
https://www.reddit.com/r/rust/comments/5836mf/working_with_arrayfire_and_large_arrays/
.

Any tips on what I'm doing wrong and could try? Or would ArrayFire not be
the appropriate choice for this type of work on the GPU? I'm thinking I
need to do the permutations via ArrayFire in GPU memory via some
batching/loop?

—
You are receiving this because you were assigned.
Reply to this email directly, view it on GitHub
#52 (comment),
or mute the thread
https://github.com/notifications/unsubscribe-auth/ADHnOr7hDiVo4JeXFdfdXb4lfQpPlEnVks5q1KnngaJpZM4GzyTy
.