void run_test (FILE *data_stream, FILE *test_in, FILE *test_out)
{
int num_of_request;
unsigned short ordered_rids[100];
char num_of_request_str[10];
char target_key[20];
struct page result;
num_of_request = atoi (fget_num (num_of_request_str, 10, test_in));
while (num_of_request--)
{
init_page (&result, true);
fget_num (target_key, 20, test_in); // Get a request.
if (search_by_key (target_key, &result, data_stream)) // sth worng here!!!
{
sort_record_in_page (&result, 2, ordered_rids);
put_result (&result, ordered_rids, test_out);
}
else
fprintf (test_out, "%d\r\n", -1);
}
}
// this example demostrates a black-scholes option pricing kernel.
int main()
{
// number of options
const int N = 4000000;
// black-scholes parameters
const float risk_free_rate = 0.02f;
const float volatility = 0.30f;
// get default device and setup context
compute::device gpu = compute::system::default_device();
compute::context context(gpu);
compute::command_queue queue(context, gpu);
std::cout << "device: " << gpu.name() << std::endl;
// initialize option data on host
std::vector<float> stock_price_data(N);
std::vector<float> option_strike_data(N);
std::vector<float> option_years_data(N);
std::srand(5347);
for(int i = 0; i < N; i++){
stock_price_data[i] = rand_float(5.0f, 30.0f);
option_strike_data[i] = rand_float(1.0f, 100.0f);
option_years_data[i] = rand_float(0.25f, 10.0f);
}
// create memory buffers on the device
compute::vector<float> call_result(N, context);
compute::vector<float> put_result(N, context);
compute::vector<float> stock_price(N, context);
compute::vector<float> option_strike(N, context);
compute::vector<float> option_years(N, context);
// copy initial values to the device
compute::copy_n(stock_price_data.begin(), N, stock_price.begin(), queue);
compute::copy_n(option_strike_data.begin(), N, option_strike.begin(), queue);
compute::copy_n(option_years_data.begin(), N, option_years.begin(), queue);
// source code for black-scholes program
const char source[] = BOOST_COMPUTE_STRINGIZE_SOURCE(
// approximation of the cumulative normal distribution function
float cnd(float d)
{
const float A1 = 0.319381530f;
const float A2 = -0.356563782f;
const float A3 = 1.781477937f;
const float A4 = -1.821255978f;
const float A5 = 1.330274429f;
const float RSQRT2PI = 0.39894228040143267793994605993438f;
float K = 1.0f / (1.0f + 0.2316419f * fabs(d));
float cnd =
RSQRT2PI * exp(-0.5f * d * d) *
(K * (A1 + K * (A2 + K * (A3 + K * (A4 + K * A5)))));
if(d > 0){
cnd = 1.0f - cnd;
}
return cnd;
}
// black-scholes option pricing kernel
__kernel void black_scholes(__global float *call_result,
__global float *put_result,
__global const float *stock_price,
__global const float *option_strike,
__global const float *option_years,
float risk_free_rate,
float volatility)
{
const uint opt = get_global_id(0);
float S = stock_price[opt];
float X = option_strike[opt];
float T = option_years[opt];
float R = risk_free_rate;
float V = volatility;
float sqrtT = sqrt(T);
float d1 = (log(S / X) + (R + 0.5f * V * V) * T) / (V * sqrtT);
float d2 = d1 - V * sqrtT;
float CNDD1 = cnd(d1);
float CNDD2 = cnd(d2);
float expRT = exp(-R * T);
call_result[opt] = S * CNDD1 - X * expRT * CNDD2;
put_result[opt] = X * expRT * (1.0f - CNDD2) - S * (1.0f - CNDD1);
}
);