cl_int Dgemm_internal(
cl_env *env, double *a, double *b, double *c, double alpha, double beta,
clblasTranspose transA, clblasTranspose transB,
int ar, int ac, int br, int bc, int cr, int cc, int size_a, int size_b, int size_c)
{
CHECK(clblasSetup());
cl_event events[NEVENTS];
int nevent = 0;
cl_mem mem_a = create_mem(env, a, size_a, CL_MEM_READ_ONLY, &(events[nevent++]));
cl_mem mem_b = create_mem(env, b, size_b, CL_MEM_READ_ONLY, &(events[nevent++]));
cl_mem mem_c;
if (beta != 0) mem_c = create_mem(env, c, size_c, CL_MEM_READ_WRITE, &(events[nevent++]));
else mem_c = create_mem(env, NULL, size_c, CL_MEM_READ_WRITE, NULL);
cl_int err = clblasDgemm(clblasColumnMajor, transA, transB,
ar, bc, ac, alpha, mem_a, 0, ar, mem_b, 0, br, beta, mem_c, 0, cr,
1, &(env->queues[0]), nevent, events, &(events[nevent]));
CHECK(err);
events[nevent+1] = *read_mem(env, mem_c, c, size_c, 1, &(events[nevent]));
CHECK(clWaitForEvents(1, &(events[nevent+1])));
CHECK(clReleaseMemObject(mem_a));
CHECK(clReleaseMemObject(mem_b));
CHECK(clReleaseMemObject(mem_c));
clblasTeardown();
return CL_SUCCESS;
}
/*
* A Test Program for monitors
* Principle: Prog1 works together with Prog2
* They are testing the wait and notify function as well as the integrity of a shared variable
* Prog2 is testing the enter-exit behavior with timeouts
* Prog3 is testing the function x_thread_stop_waiting(x_thread thread)
*/
void monitor_testprogram(void* args){
int t;
m_thread = malloc(11 * sizeof(x_Thread));
m_stack = malloc(11 * stacksize);
monitor = (x_monitor) malloc(sizeof(x_Monitor));
monitor2 = (x_monitor) malloc(sizeof(x_Monitor));
monitor3 = (x_monitor) malloc(sizeof(x_Monitor));
teller=0;
ERROR = FALSE;
create_mem();
x_monitor_create(monitor);
x_monitor_create(monitor2);
x_monitor_create(monitor3);
for(t=0;t<3;t++){
x_thread_create(mstruct[t],&prog1,(void*)t,mstack[t],stacksize,5,TF_START);
}
for(t=3;t<6;t++){
x_thread_create(mstruct[t],&prog2,(void*)t,mstack[t],stacksize,5,TF_START);
}
for(t=6;t<9;t++){
x_thread_create(mstruct[t],&prog3,(void*)t,mstack[t],stacksize,5,TF_START);
}
for(t=9;t<10;t++){
x_thread_create(mstruct[t],&prog4,(void*)t,mstack[t],stacksize,4,TF_START);
}
x_thread_suspend(x_thread_current());
}
bool_t create_stringlist(stringlist_t *sl) {
if( sl ) {
sl->num = 0;
sl->flags = 0;
return create_mem(&sl->list, &sl->max, sizeof(char_t *), 16);
}
return FALSE;
}
bool_t create_jumptable(jumptable_t *jt) {
if( jt ) {
jt->num = 0;
create_mem(&jt->hash, &jt->maxnum, sizeof(jump_t), 16);
return TRUE;
}
return FALSE;
}
bool_t create_symbols(symbols_t *sb) {
if( sb ) {
create_mem(&sb->bigs, &sb->bigmax, sizeof(byte_t), 64);
sb->bigs_len = 0;
sb->last = -1;
create_jumptable(&sb->jt);
return TRUE;
}
return FALSE;
}
bool_t create_cursor(cursor_t *cursor) {
bool_t ok = TRUE;
if( cursor ) {
cursor->top = 0;
ok &= create_mem(&cursor->stack, &cursor->stacklen,
sizeof(coff_t), CURSOR_MINSTACK);
if( ok ) { reset_cursor(cursor); }
return ok;
}
return FALSE;
}
bool_t create_attlist(attlist_t *alist) {
bool_t ok = TRUE;
if( alist ) {
alist->count = 0;
ok &= create_mem(&alist->list, &alist->max_count,
sizeof(attribute_t), 16);
if( ok ) { reset_attlist(alist); }
return ok;
}
return FALSE;
}
cl_int Dtrmm_internal(
cl_env *env, double *a, double *b, double alpha, clblasSide side, clblasTranspose transA,
clblasUplo uplo, clblasDiag diag, int ar, int ac, int br, int bc, int size_a, int size_b)
{
CHECK(clblasSetup());
cl_event events[NEVENTS];
int nevent = 0;
cl_mem mem_a = create_mem(env, a, size_a, CL_MEM_READ_ONLY, &(events[nevent++]));
cl_mem mem_b = create_mem(env, b, size_b, CL_MEM_READ_WRITE, &(events[nevent++]));
cl_int err = clblasDtrmm(clblasColumnMajor, side, uplo, transA, diag,
br, bc, alpha, mem_a, 0, ar, mem_b, 0, br,
1, &(env->queues[0]), nevent, events, &(events[nevent]));
CHECK(err);
events[nevent+1] = *read_mem(env, mem_b, b, size_b, 1, &(events[nevent]));
CHECK(clWaitForEvents(1, &(events[nevent+1])));
CHECK(clReleaseMemObject(mem_a));
CHECK(clReleaseMemObject(mem_b));
clblasTeardown();
return CL_SUCCESS;
}
cl_int Dsyrk_internal(
cl_env *env, double *a, double *c, double alpha, double beta,
clblasTranspose transA, clblasUplo uplo, int ar, int ac, int n, int size_a, int size_c)
{
CHECK(clblasSetup());
cl_event events[NEVENTS];
int nevent = 0;
cl_mem mem_a = create_mem(env, a, size_a, CL_MEM_READ_ONLY, &(events[nevent++]));
cl_mem mem_c;
if (beta != 0) mem_c = create_mem(env, c, size_c, CL_MEM_READ_WRITE, &(events[nevent++]));
else mem_c = create_mem(env, NULL, size_c, CL_MEM_READ_WRITE, NULL);
int k = transA == clblasNoTrans ? ar : ac;
cl_int err = clblasDsyrk(clblasColumnMajor, uplo, transA,
n, k, alpha, mem_a, 0, ac, beta, mem_c, 0, n,
1, &(env->queues[0]), nevent, events, &(events[nevent]));
CHECK(err);
events[nevent+1] = *read_mem(env, mem_c, c, size_c, 1, &(events[nevent]));
CHECK(clWaitForEvents(1, &(events[nevent+1])));
CHECK(clReleaseMemObject(mem_a));
CHECK(clReleaseMemObject(mem_c));
clblasTeardown();
return CL_SUCCESS;
}
int main (int argc, char **argv) {
int qflag = 0;
unsigned long int m_size = UINT_MAX;
int object_size;
int n_procs = 1;
unsigned long int i = 0;
unsigned long int j = 0;
int n = 0;
pid_t pids[n_procs];
pid_t pid;
int status;
parse_com(argc, argv, &qflag, &m_size, &n_procs);
unsigned int *bitmap;
object_size = UINT_MAX/8 + 4;
//create shared memory
void *addr = create_mem("/hazlettb_prime", object_size);
bitmap = (unsigned int*)addr;
//set up bitmap for sieve
for (i=3;i<m_size;i+=2)
setBit(bitmap,i);
//fork the children
for (i = 0; i < n_procs; ++i) {
if ((pids[i] = fork()) < 0) {
perror("fork");
abort();
}
else if (pids[i] == 0) {
//each child calculates and stores some of the primes
n = 3 + 2*i;
for (i = n; i < m_size; i+=(2*n_procs)){
if (testBit(bitmap, i))
for (j=i;i*j<m_size;j++)
clearBit(bitmap,(i*j));
}
exit(0);
}
}
//wait for children to exit
while (n_procs > 0) {
pid = wait(&status);
--n_procs;
}
//step through array, check for twins and print if no q
for (i = 0; i < (m_size - 2); i++) {
if (testBit(bitmap, i) && testBit(bitmap,(i+2))) {
if (qflag == 0)
printf("%lu %lu\n", i, i + 2);
}
}
//unlink memory object
if (shm_unlink("/hazlettb_prime") == -1)
printf("unlink failed");
return 0;
}
