Finding if a value is among an array using a FPGA
Well, to store 15K 64-bit values you need a reasonable number (i.e. about 64) BlockRams which you can access in parallel. They typically have dual ports, so you can potentially perform 128 comparisons in parallel. Each BlockRam (16k bits) stores 256 64-bit values, and can expose 2 values per cycle, so even a linear search will only take 128 cycles.

You might dedicate two entries in each BlockRam to every 128th value from the list, and perform a binning comparison; if your match is between bins 17 and 18, then address location 17 within every BlockRam, then one further operation will test that entire bin. (Oops; as you lost one location out of 128 for the bin search, make that every 127th value...)

Consider your sample address in the range 0 to 16000 as N * 127 + M where:
N ranges from 0 to 127 (128 bins)
M ranges from 0 to 126 (127 values within each bin).

First comparison (bin comparison) accesses 128 values, stored in location 127 (and 255 on the second port) within each BlockRam. These values are list entries N*127 + 0 for all N in 0 to 127.
For some N, value(N) &lt;= match &lt; value(N+1) - thus bin N is the bin to search further. Note this requires a relational comparison

Now we address location N in every BlockRam and perform an equality comparison.
Each BlockRam contains (in its Nth address) value (N + M) for M from 0 to 126.
NB this means the last BlockRam is unused and we only perform 127 equality comparisons. If one of these M matches, compute N*127+M, otherwise signal failure.

Takes a little more than 2 cycles thanks to the indirection and BlockRam being synchronous memory, but probably fast enough for your purpose. I doubt a GPU can match 3 cycles...

I'm assuming it's cheap enough to pre-sort and interleave the list, probably in software on the host, before loading it into the BlockRams.

So the data is interleaved such that the Nth BlockRam contains   

Address    Data   
0          List(0*127 + N)   
1          List(1*127 + N)   
2          List(2*127 + N)   
...   
126        List(126*127 + N)   
127        List(N*127 + 0) (the bin comparison value)