filename stringlengths 19 182 | omp_pragma_line stringlengths 24 416 | context_chars int64 100 100 | text stringlengths 152 177k |
|---|---|---|---|
amannougrahiya/imop-compiler/tests/imsuite/src/mst.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | would have happened.
*/
DEBUG("finding the minimum of the accumulated blue edges\n");
<LOOP-START>for (int i = 0; i < g->N; i++) {
node* u = elem_at(&g->vertices, i);
payload* u_data = u->data;
/* only roots find the blue edge */
if (u_data->fragment_id != u->label)
... |
amannougrahiya/imop-compiler/tests/imsuite/src/mst.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | @g: the graph
*/
void assign_tmp_fragments(graph* g) {
DEBUG("setting tmp_fragment_id\n");
<LOOP-START>for (int i = 0; i < g->N; i++) {
node* u = elem_at(&g->vertices, i);
payload* u_data = u->data;
node* leader = elem_at(&g->vertices, u_data->fragment_id);
payload* leader_data... |
amannougrahiya/imop-compiler/tests/imsuite/src/mst.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | data->tmp_fragment_id = leader_data->b->u;
}
DEBUG("setting temporary fragment_id\n");
<LOOP-START>for (int i = 0; i < g->N; i++) {
node* u = elem_at(&g->vertices, i);
payload* u_data = u->data;
u_data->fragment_id = u_data->tmp_fragment_id;
}<LOOP-END> <OMP-START>#pragma omp p... |
amannougrahiya/imop-compiler/tests/imsuite/src/mst.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | r.
*/
for (int ok = 0; ok < 2; ok++) {
DEBUG("conflicts phase: %d\n", ok);
<LOOP-START>for (int i = 0; i < g->N; i++) {
node* u = elem_at(&g->vertices, i);
payload* u_data = u->data;
if (u_data->fragment_id != u->label)
continue;
... |
amannougrahiya/imop-compiler/tests/imsuite/src/mis.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | r each node.
*
* @g: a pointer to the graph object
*/
void generate_random_field(graph* g) {
<LOOP-START>for (int i = 0; i < g->N; i++) {
node* cur = elem_at(&g->vertices, i);
payload* data = cur->data;
if (!data->present)
continue;
data->r = randnum();
}<LOOP-EN... |
amannougrahiya/imop-compiler/tests/imsuite/src/mis.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | entering the MIS.
*
* @g: a pointer to the graph object
*/
void decide_mis_entry(graph* g) {
<LOOP-START>for (int i = 0; i < g->N; i++) {
node* cur = elem_at(&g->vertices, i);
payload* data = cur->data;
if (!data->present)
continue;
int enter = 1;
for... |
amannougrahiya/imop-compiler/tests/imsuite/src/mis.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | ve them.
*
* @g: a pointer to the graph object
*/
void remove_mis_adjacent_nodes(graph* g) {
<LOOP-START>for (int i = 0; i < g->N; i++) {
node* cur = elem_at(&g->vertices, i);
payload* data = cur->data;
if (data->in_mis) {
for (int i = 0; i < cur->degree; i++) {
... |
amannougrahiya/imop-compiler/tests/imsuite/src/mis.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | nodes, returns 0 otherwise.
*/
int do_present_nodes_exist(graph* g) {
int keep_going = 0;
<LOOP-START>for (int i = 0; i < g->N; i++) {
node* cur = elem_at(&g->vertices, i);
payload* data = cur->data;
if (data->present)
keep_going = 1;
}<LOOP-END> <OMP-START>#pragma omp... |
amannougrahiya/imop-compiler/tests/imsuite/src/byzantine.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | sors, int N) {
int ret = 0;
DEBUG("checking if there are any undecided processors\n");
<LOOP-START>for (int i = 0; i < N; i++) {
processor* p = processors+i;
if (p->decided == 0)
ret = 1;
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(SCHEDULING_METHOD)<OMP-END> |
amannougrahiya/imop-compiler/tests/imsuite/src/byzantine.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | st_vote(processor* processors, int N, queuelist* vote_ql) {
DEBUG("broadcasting votes\n");
<LOOP-START>for (int i = 0; i < N; i++) {
processor* p = processors+i;
for (int j = 0; j < N; j++) {
if (i == j)
continue;
vote v = {i, p->vote};
enqu... |
amannougrahiya/imop-compiler/tests/imsuite/src/byzantine.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | a queuelist of votes
*/
void receive_votes(processor* processors, int N, queuelist* vote_ql) {
<LOOP-START>for (int i = 0; i < N; i++) {
processor* p = processors+i;
int yes = 0;
int no = 0;
while (!is_ql_queue_empty(vote_ql, i)) {
vote* v = dequeue(vote_ql, i);
... |
amannougrahiya/imop-compiler/tests/imsuite/src/bellman_ford.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | messages, 0 otherwise.
*/
int messages_in_queue(int N, queuelist* recv) {
int result = 0;
<LOOP-START>for (int i = 0; i < N; i++) {
if (!is_ql_queue_empty(recv, i))
result = 1;
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(SCHEDULING_METHOD)<OMP-END> |
amannougrahiya/imop-compiler/tests/imsuite/src/bellman_ford.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | d(graph* g, queuelist* recv, queuelist* send) {
DEBUG("receiving and sending messages\n");
<LOOP-START>for (int i = 0; i < g->N; i++) {
node* u = elem_at(&g->vertices, i);
payload* u_data = u->data;
int lowest_y = INT_MAX;
int lowest_from = 0;
while (!is_ql_queue_empty(... |
amannougrahiya/imop-compiler/tests/imsuite/src/bellman_ford.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | recv, queuelist* send) {
DEBUG("propagating messages from the send queuelist to recv\n");
<LOOP-START>for (int i = 0; i < g->N; i++) {
node* u = elem_at(&g->vertices, i);
while (!is_ql_queue_empty(send, u->label))
enqueue(recv, u->label, dequeue(send, u->label));
}<LOOP-END> <... |
amannougrahiya/imop-compiler/tests/imsuite/src/vertex_coloring.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | k and 0
* if none of the nodes need to colored.
*/
int again(graph* g) {
int result = 0;
<LOOP-START>for (int i = 0; i < g->N; i++) {
node* u = elem_at(&g->vertices, i);
payload* u_data = u->data;
if (u_data->again)
result = 1;
}<LOOP-END> <OMP-START>#pragma omp paral... |
amannougrahiya/imop-compiler/tests/imsuite/src/vertex_coloring.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | ts children.
*
* @g: the graph
*/
void parent_to_child(graph* g) {
DEBUG("starting\n");
<LOOP-START>for(int i = 0; i < g->N; i++) {
node* u = elem_at(&g->vertices, i);
payload* u_data = u->data;
if (u->label != ROOT) {
node* parent = elem_at(&g->vertices, u_data->parent)... |
amannougrahiya/imop-compiler/tests/imsuite/src/vertex_coloring.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 |
void six_color_tree(graph *g, int digits) {
DEBUG("starting\n");
parent_to_child(g);
<LOOP-START>for(int i = 0; i < g->N; i++) {
node* u = elem_at(&g->vertices, i);
payload* u_data = u->data;
if(u->label == ROOT)
continue;
u_data->again = 0;
int xor ... |
amannougrahiya/imop-compiler/tests/imsuite/src/leader_elect_dp.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | neighbor's x value.
*
* @g: a pointer to the graph
*/
void calculate_temporary_x(graph* g) {
<LOOP-START>for (int i = 0; i < g->N; i++) {
node* cur = elem_at(&g->vertices, i);
processor* p = cur->data;
int new_x = p->x;
for (int j = 0; j < cur->degree; j++) {
node* ne... |
amannougrahiya/imop-compiler/tests/imsuite/src/leader_elect_dp.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | if there was a change.
*/
int propagate_temporary_x(graph* g) {
int something_changed = 0;
<LOOP-START>for (int i = 0; i < g->N; i++) {
node* cur = elem_at(&g->vertices, i);
processor* p = cur->data;
if (p->new_x != p->x)
something_changed = 1;
p->x = p->new_x;
... |
amannougrahiya/imop-compiler/tests/imsuite/src/dominating_set.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | he graph nodes with the payload data.
*
* @g: the graph
*/
void initialize_graph(graph* g) {
<LOOP-START>for (int i = 0; i < g->N; i++) {
node* v = elem_at(&g->vertices, i);
payload* data = malloc(sizeof(payload));
data->color = WHITE;
data->joined = 0;
initialize_vecto... |
amannougrahiya/imop-compiler/tests/imsuite/src/dominating_set.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | de (WHITE nodes), 0
* otherwise.
*/
int unjoined_nodes_exist(graph* g) {
int result = 0;
<LOOP-START>for (int i = 0; i < g->N; i++) {
node* v = elem_at(&g->vertices, i);
payload* data = v->data;
if (data->color == WHITE) {
DEBUG("%d->color = WHITE\n", v->label);
... |
amannougrahiya/imop-compiler/tests/imsuite/src/dominating_set.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | w for each vertex.
*
* @g: the graph
*/
void compute_w(graph* g) {
DEBUG("starting\n");
<LOOP-START>for (int i = 0; i < g->N; i++) {
node* v = elem_at(&g->vertices, i);
payload* v_data = v->data;
v_data->W.used = 0;
if (v_data->color == WHITE)
append_to_vector(&... |
amannougrahiya/imop-compiler/tests/imsuite/src/dominating_set.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | each vertex.
*
* @g: the graph
*/
void compute_w_tilde(graph* g) {
DEBUG("starting\n");
<LOOP-START>for (int i = 0; i < g->N; i++) {
node* v = elem_at(&g->vertices, i);
payload* v_data = v->data;
v_data->w_tilde = ceil_power_of_2(v_data->w);
DEBUG("%d->w_tilde = %d\n", v->la... |
amannougrahiya/imop-compiler/tests/imsuite/src/dominating_set.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | r each vertex.
*
* @g: the graph
*/
void compute_w_hat(graph* g) {
DEBUG("starting\n");
<LOOP-START>for (int i = 0; i < g->N; i++) {
node* v = elem_at(&g->vertices, i);
payload* v_data = v->data;
if (v_data->W.used == 0)
continue;
int w_hat = 0;
for (int... |
amannougrahiya/imop-compiler/tests/imsuite/src/dominating_set.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | ctive or not.
*
* @g: the graph
*/
void compute_active(graph* g) {
DEBUG("starting\n");
<LOOP-START>for (int i = 0; i < g->N; i++) {
node* v = elem_at(&g->vertices, i);
payload* v_data = v->data;
if (v_data->W.used == 0)
continue;
if (v_data->w_hat == v_data->w_... |
amannougrahiya/imop-compiler/tests/imsuite/src/dominating_set.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | ort for each node.
*
* @g: the graph
*/
void compute_s(graph* g) {
DEBUG("starting\n");
<LOOP-START>for (int i = 0; i < g->N; i++) {
node* v = elem_at(&g->vertices, i);
payload* v_data = v->data;
if (v_data->W.used == 0)
continue;
int support = v_data->active;
... |
amannougrahiya/imop-compiler/tests/imsuite/src/dominating_set.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | mized fashion.
*
* @g: the graph
*/
void compute_s_hat(graph* g) {
DEBUG("starting\n");
<LOOP-START>for (int i = 0; i < g->N; i++) {
node* v = elem_at(&g->vertices, i);
payload* v_data = v->data;
if (v_data->W.used == 0)
continue;
int s_hat = 0;
for (int... |
amannougrahiya/imop-compiler/tests/imsuite/src/dominating_set.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | d fashion.
*
* @g: the graph
*/
void compute_candidacy(graph* g) {
DEBUG("starting\n");
<LOOP-START>for (int i = 0; i < g->N; i++) {
node* v = elem_at(&g->vertices, i);
payload* v_data = v->data;
if (v_data->W.used == 0)
continue;
v_data->candidate = 0;
... |
amannougrahiya/imop-compiler/tests/imsuite/src/dominating_set.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 |
* of each node).
*
* @g: the graph
*/
void compute_c(graph* g) {
DEBUG("starting\n");
<LOOP-START>for (int i = 0; i < g->N; i++) {
node* v = elem_at(&g->vertices, i);
payload* v_data = v->data;
if (v_data->W.used == 0)
continue;
v_data->c = 0;
for (int... |
amannougrahiya/imop-compiler/tests/imsuite/src/dominating_set.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | es the w value.
*
* @g: the graph
*/
void compute_join(graph* g) {
DEBUG("starting\n");
<LOOP-START>for (int i = 0; i < g->N; i++) {
node* v = elem_at(&g->vertices, i);
payload* v_data = v->data;
if (v_data->W.used == 0)
continue;
int sigma_c = 0;
for (i... |
amannougrahiya/imop-compiler/tests/imsuite/src/dominating_set.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | nating set or not).
*
* @g: the graph
*/
void colorize(graph* g) {
DEBUG("starting\n");
<LOOP-START>for (int i = 0; i < g->N; i++) {
node* v = elem_at(&g->vertices, i);
payload* v_data = v->data;
if (v_data->color != WHITE)
continue;
for (int j = 0; j < v->degre... |
amannougrahiya/imop-compiler/tests/imsuite/src/bfs_dijkstra.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | graph object
*/
void initialize_graph(graph* g) {
// allocate the data field for each node
<LOOP-START>for (int i = 0; i < g->N; i++) {
node* cur = elem_at(&g->vertices, i);
payload* data = malloc(sizeof(payload));
data->parent_label = -1;
data->phase_discovered = -1;
... |
amannougrahiya/imop-compiler/tests/imsuite/src/bfs_dijkstra.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | e
* discovered.
*/
int broadcast_start(graph* g, int p) {
int nobody_was_discovered = 1;
<LOOP-START>for (int i = 0; i < g->N; i++) {
node* cur = elem_at(&g->vertices, i);
payload* data = cur->data;
// this node was just discovered in phase `p`
if (data->phase_discovered == p... |
amannougrahiya/imop-compiler/tests/imsuite/src/kcommittee.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | s `min_active` to its neighbors.
*/
DEBUG("broadcasting `min_active`s\n");
<LOOP-START>for (int i = 0; i < g->N; i++) {
node* cur = elem_at(&g->vertices, i);
payload* data = cur->data;
if (data->committee == g->N+1)
data->min_active = data->d... |
amannougrahiya/imop-compiler/tests/imsuite/src/kcommittee.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | adcasted `min_active`s.
*/
DEBUG("receiving broadcasted transmissions\n");
<LOOP-START>for (int i = 0; i < g->N; i++) {
node* cur = elem_at(&g->vertices, i);
payload* data = cur->data;
while(!is_ql_queue_empty(active_ql, i)) {
int* active = d... |
amannougrahiya/imop-compiler/tests/imsuite/src/kcommittee.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | * invite_ql) {
DEBUG("starting selection\n");
DEBUG("creating initial invitations\n");
<LOOP-START>for (int i = 0; i < g->N; i++) {
node* cur = elem_at(&g->vertices, i);
payload* data = cur->data;
if (data->leader == data->default_leader) {
data->invite.x = i;
... |
amannougrahiya/imop-compiler/tests/imsuite/src/kcommittee.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | roadcast invitations to neighbors.
*/
DEBUG("broadcasting invitations\n");
<LOOP-START>for (int i = 0; i < g->N; i++) {
node* cur = elem_at(&g->vertices, i);
payload* data = cur->data;
for (int j = 0; j < cur->degree; j++) {
node* neighbor = ... |
amannougrahiya/imop-compiler/tests/imsuite/src/kcommittee.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 |
* smallest one.
*/
DEBUG("receiving broadcasted invitations\n");
<LOOP-START>for (int i = 0; i < g->N; i++) {
node* cur = elem_at(&g->vertices, i);
payload* data = cur->data;
while (!is_ql_queue_empty(invite_ql, i)) {
invitation* in... |
amannougrahiya/imop-compiler/tests/imsuite/src/kcommittee.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | legalize_committees(graph* g) {
DEBUG("making sure there aren't any illegal committees\n");
<LOOP-START>for (int i = 0; i < g->N; i++) {
node* cur = elem_at(&g->vertices, i);
payload* data = cur->data;
if (data->committee >= g->N)
data->committee = i;
}<LOOP-END> <OMP-ST... |
amannougrahiya/imop-compiler/tests/imsuite/src/leader_elect_hs.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | queuelist* send_ql) {
DEBUG("Generating 2*%d messages for %d processes\n", N, N);
<LOOP-START>for (int i = 0; i < N; i++) {
process* p = processes+i;
/**
* If this node has been asked (or decided) to not send out any more
* original messages (all nodes will always be... |
amannougrahiya/imop-compiler/tests/imsuite/src/leader_elect_hs.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | queuelist* recv_ql) {
DEBUG("propagating messages on phase %d\n", l);
<LOOP-START>for (int i = 0; i < N; i++) {
DEBUG("i = %d\n", i);
process* p = processes+i;
while (!is_ql_queue_empty(send_ql, i)) {
message* m = dequeue(send_ql, i);
DEBUG(... |
amannougrahiya/imop-compiler/tests/imsuite/src/leader_elect_hs.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | n will automatically set the number of elements to zero after
* the last element.
*/
<LOOP-START>for (int i = 0; i < N; i++) {
process* p = processes+i;
while (!is_ql_queue_empty(recv_ql, i)) {
enqueue(send_ql, i, dequeue(recv_ql, i));
}
}<LOOP-END> <OMP-START>#pr... |
amannougrahiya/imop-compiler/tests/imsuite/src/leader_elect_lcr.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | cesses
* @n: number of processes
*/
void receive_leaders(process* processes, int N) {
<LOOP-START>for (int i = 0; i < N; i++) {
int next = (i+1) % N;
processes[next].received = processes[i].send;
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(SCHEDULING_METHOD)<OMP-END> |
amannougrahiya/imop-compiler/tests/imsuite/src/leader_elect_lcr.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | sses
* @n: number of processes
*/
void determine_leaders(process* processes, int N) {
<LOOP-START>for (int i = 0; i < N; i++) {
if (processes[i].received > processes[i].leader) {
processes[i].send = processes[i].received;
processes[i].leader = processes[i].received;
... |
amannougrahiya/imop-compiler/tests/imsuite/src/leader_elect_lcr.c | #pragma omp parallel for schedule(SCHEDULING_METHOD) | 100 | he chosen leader.
*/
int identify_leader(process* processes, int N) {
int chosen_id = -1;
<LOOP-START>for (int i = 0; i < N; i++) {
if (processes[i].status == 1) {
chosen_id = i;
// this will happen at most once
}
}<LOOP-END> <OMP-START>#pragma omp parallel for sche... |
amannougrahiya/imop-compiler/tests/polybench-c-3.2/utilities/polybench.c | #pragma omp parallel for | 100 | double* flush = (double*) calloc (cs, sizeof(double));
int i;
double tmp = 0.0;
#ifdef _OPENMP
<LOOP-START>for (i = 0; i < cs; i++)
tmp += flush[i];
assert (tmp <= 10.0);
free (flush);
}
#ifdef POLYBENCH_LINUX_FIFO_SCHEDULER
void polybench_linux_fifo_scheduler()
{
/* Use FIFO scheduler to limit OS inte... |
amannougrahiya/imop-compiler/runner/NPB3.0-omp-C-master/CG/cg-orig.c | #pragma omp parallel for default(shared) private(j) reduction(+:norm_temp11,norm_temp12) | 100 | ---------------------------------------------------------*/
norm_temp11 = 0.0;
norm_temp12 = 0.0;
<LOOP-START>for (j = 1; j <= lastcol-firstcol+1; j++) {
norm_temp11 = norm_temp11 + x[j]*z[j];
norm_temp12 = norm_temp12 + z[j]*z[j];
}<LOOP-END> <OMP-START>#pragma omp parallel for default(share... |
amannougrahiya/imop-compiler/runner/NPB3.0-omp-C-master/CG/cg-orig.c | #pragma omp parallel for default(shared) private(j) | 100 | -
c Normalize z to obtain x
c-------------------------------------------------------------------*/
<LOOP-START>for (j = 1; j <= lastcol-firstcol+1; j++) {
x[j] = norm_temp12*z[j];
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(j)<OMP-END> |
amannougrahiya/imop-compiler/runner/NPB3.0-omp-C-master/CG/cg-orig.c | #pragma omp parallel for default(shared) private(i) | 100 | ing vector to (1, 1, .... 1)
c-------------------------------------------------------------------*/
<LOOP-START>for (i = 1; i <= NA+1; i++) {
x[i] = 1.0;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i)<OMP-END> |
amannougrahiya/imop-compiler/runner/NPB3.0-omp-C-master/CG/cg-orig.c | #pragma omp parallel for default(shared) private(j) reduction(+:norm_temp11,norm_temp12) | 100 | --------------------------------------------------------*/
norm_temp11 = 0.0;
norm_temp12 = 0.0;
<LOOP-START>for (j = 1; j <= lastcol-firstcol+1; j++) {
norm_temp11 = norm_temp11 + x[j]*z[j];
norm_temp12 = norm_temp12 + z[j]*z[j];
}<LOOP-END> <OMP-START>#pragma omp parallel for default(share... |
amannougrahiya/imop-compiler/runner/NPB3.0-omp-C-master/CG/cg-orig.c | #pragma omp parallel for default(shared) private(j) | 100 | -
c Normalize z to obtain x
c-------------------------------------------------------------------*/
<LOOP-START>for (j = 1; j <= lastcol-firstcol+1; j++) {
x[j] = norm_temp12*z[j];
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(j)<OMP-END> |
amannougrahiya/imop-compiler/runner/NPB3.0-omp-C-master/CG/cg-orig.c | #pragma omp parallel for default(shared) private(i) | 100 | to mark nonzero positions
c---------------------------------------------------------------------*/
<LOOP-START>for (i = 1; i <= n; i++) {
colidx[n+i] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i)<OMP-END> |
amannougrahiya/imop-compiler/runner/NPB3.0-omp-C-master/CG/cg-orig.c | #pragma omp parallel for default(shared) private(j) | 100 | umber of triples in each row
c-------------------------------------------------------------------*/
<LOOP-START>for (j = 1; j <= n; j++) {
rowstr[j] = 0;
mark[j] = FALSE;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(j)<OMP-END> |
amannougrahiya/imop-compiler/runner/NPB3.0-omp-C-master/CG/cg-orig.c | #pragma omp parallel for default(shared) private(k,j) | 100 | ... preload data pages
c---------------------------------------------------------------------*/
<LOOP-START>for(j = 0;j <= nrows-1;j++) {
for(k = rowstr[j];k <= rowstr[j+1]-1;k++)
a[k] = 0.0;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(k,j)<OMP-END> |
amannougrahiya/imop-compiler/runner/NPB3.0-omp-C-master/CG/cg-orig.c | #pragma omp parallel for default(shared) private(i) | 100 | adding elements
c-------------------------------------------------------------------*/
nza = 0;
<LOOP-START>for (i = 1; i <= n; i++) {
x[i] = 0.0;
mark[i] = FALSE;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i) <OMP-END> |
amannougrahiya/imop-compiler/runner/NPB3.0-omp-C-master/FT/ft-orig.c | #pragma omp parallel for default(shared) private(i,j,k) | 100 | ier space
c-------------------------------------------------------------------*/
int i, j, k;
<LOOP-START>for (k = 0; k < d[2]; k++) {
for (j = 0; j < d[1]; j++) {
for (i = 0; i < d[0]; i++) {
crmul(u1[k][j][i], u0[k][j][i], ex[t*indexmap[k][j][i]]);
}
}
}<LOOP-END> <OMP-START>#pragm... |
amannougrahiya/imop-compiler/runner/NPB3.0-omp-C-master/FT/ft-orig.c | #pragma omp parallel for default(shared) private(i,j,k,ii,ii2,jj,ij2,kk) | 100 | ck:
c mod(i-1+n/2, n) - n/2
c-------------------------------------------------------------------*/
<LOOP-START>for (i = 0; i < dims[2][0]; i++) {
ii = (i+1+xstart[2]-2+NX/2)%NX - NX/2;
ii2 = ii*ii;
for (j = 0; j < dims[2][1]; j++) {
jj = (j+1+ystart[2]-2+NY/2)%NY - NY/2;
ij2 = jj*jj+ii2;
... |
amannougrahiya/imop-compiler/runner/NPB3.0-omp-C-master/SP/sp-orig.c | #pragma omp parallel for default(shared) private(i,j,k,r1,r2,r3,r4,r5,t1,t2) | 100 | --------------------------------------------*/
int i, j, k;
double r1, r2, r3, r4, r5, t1, t2;
<LOOP-START>for (i = 1; i <= grid_points[0]-2; i++) {
for (j = 1; j <= grid_points[1]-2; j++) {
for (k = 1; k <= grid_points[2]-2; k++) {
r1 = rhs[0][i][j][k];
r2 = rhs[1][i][j][k];
r3 = rhs[2][i][j][k];
r... |
amannougrahiya/imop-compiler/runner/NPB3.0-omp-C-master/SP/sp-orig.c | #pragma omp parallel for default(shared) private(i,j,k,r1,r2,r3,r4,r5,t1,t2) | 100 | -------------------------------------------*/
int i, j, k;
double r1, r2, r3, r4, r5, t1, t2;
<LOOP-START>for (i = 1; i <= grid_points[0]-2; i++) {
for (j = 1; j <= grid_points[1]-2; j++) {
for (k = 1; k <= grid_points[2]-2; k++) {
r1 = rhs[0][i][j][k];
r2 = rhs[1][i][j][k];
r3 = rhs[2][i][j][k];
r... |
amannougrahiya/imop-compiler/runner/NPB3.0-omp-C-master/EP/ep-orig.c | #pragma omp parallel for default(shared) private(i) | 100 | code.
*/
vranlc(0, &(dum[0]), dum[1], &(dum[2]));
dum[0] = randlc(&(dum[1]), dum[2]);
<LOOP-START>for (i = 0; i < 2*NK; i++) x[i] = -1.0e99;
Mops = log(sqrt(fabs(max(1.0, 1.0))));
timer_clear(1);
timer_clear(2);
timer_clear(3);
timer_start(1);
vranlc(0, &t1, A, x);
/* Com... |
amannougrahiya/imop-compiler/runner/NPB3.0-omp-C-master/MG/mg.c | #pragma omp parallel for default(shared) private(i1,i2,i3,r1,r2) | 100 | ---------------------------------------------------*/
int i3, i2, i1;
double r1[M], r2[M];
<LOOP-START>for (i3 = 1; i3 < n3-1; i3++) {
for (i2 = 1; i2 < n2-1; i2++) {
for (i1 = 0; i1 < n1; i1++) {
r1[i1] = r[i3][i2-1][i1] + r[i3][i2+1][i1]
+ r[i3-1][i2][i1] + r[i3+1][i2][i1];
r2[i1] = r[... |
amannougrahiya/imop-compiler/runner/NPB3.0-omp-C-master/MG/mg.c | #pragma omp parallel for default(shared) private(i1,i2,i3,u1,u2) | 100 | ---------------------------------------------------*/
int i3, i2, i1;
double u1[M], u2[M];
<LOOP-START>for (i3 = 1; i3 < n3-1; i3++) {
for (i2 = 1; i2 < n2-1; i2++) {
for (i1 = 0; i1 < n1; i1++) {
u1[i1] = u[i3][i2-1][i1] + u[i3][i2+1][i1]
+ u[i3-1][i2][i1] + u[i3+1][i2][i1];
u2[i1] =... |
amannougrahiya/imop-compiler/runner/NPB3.0-omp-C-master/MG/mg.c | #pragma omp parallel for default(shared) private(j1,j2,j3,i1,i2,i3,x1,y1,x2,y2) | 100 | lse {
d2 = 1;
}
if (m3k == 3) {
d3 = 2;
} else {
d3 = 1;
}
<LOOP-START>for (j3 = 1; j3 < m3j-1; j3++) {
i3 = 2*j3-d3;
/*C i3 = 2*j3-1*/
for (j2 = 1; j2 < m2j-1; j2++) {
i2 = 2*j2-d2;
/*C i2 = 2*j2-1*/
for (j1 = 1; j1 < m1j; j1++) {
i... |
amannougrahiya/imop-compiler/runner/NPB3.0-omp-C-master/MG/mg.c | #pragma omp parallel for default(shared) private(i1,i2,i3,z1,z2,z3) | 100 | parameter( m=535 )
*/
double z1[M], z2[M], z3[M];
if ( n1 != 3 && n2 != 3 && n3 != 3 ) {
<LOOP-START>for (i3 = 0; i3 < mm3-1; i3++) {
for (i2 = 0; i2 < mm2-1; i2++) {
for (i1 = 0; i1 < mm1; i1++) {
z1[i1] = z[i3][i2+1][i1] + z[i3][i2][i1];
z2[i1] = z[i3+1][i2][i1] + z[i3][i2][i1];
... |
amannougrahiya/imop-compiler/runner/NPB3.0-omp-C-master/MG/mg.c | #pragma omp parallel for default(shared) private(i1,i2,i3,a) reduction(+:s) reduction(max:tmp) | 100 | --*/
double s = 0.0;
int i3, i2, i1, n;
double a = 0.0, tmp = 0.0;
n = nx*ny*nz;
<LOOP-START>for (i3 = 1; i3 < n3-1; i3++) {
for (i2 = 1; i2 < n2-1; i2++) {
for (i1 = 1; i1 < n1-1; i1++) {
s = s + r[i3][i2][i1] * r[i3][i2][i1];
a = fabs(r[i3][i2][i1]);
if (a > tmp) tmp = a;
}
... |
amannougrahiya/imop-compiler/runner/NPB3.0-omp-C-master/MG/mg.c | #pragma omp parallel for private(i2, i1) | 100 | ber\n");
for (i = MM-1; i >= 0; i--) {
printf(" %4d", jg[0][i][1]);
}
printf("\n");*/
<LOOP-START>for (i3 = 0; i3 < n3; i3++) {
for (i2 = 0; i2 < n2; i2++) {
for (i1 = 0; i1 < n1; i1++) {
z[i3][i2][i1] = 0.0;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i2, i1) <... |
amannougrahiya/imop-compiler/runner/NPB3.0-omp-C-master/MG/mg.c | #pragma omp parallel for private(i1,i2,i3) | 100 | -------
c-------------------------------------------------------------------*/
int i1, i2, i3;
<LOOP-START>for (i3 = 0;i3 < n3; i3++) {
for (i2 = 0; i2 < n2; i2++) {
for (i1 = 0; i1 < n1; i1++) {
z[i3][i2][i1] = 0.0;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i1,i2,i3)<OMP... |
Pmoonesi/multicore-processing-fcnn/phase1/genann_p.c | #pragma omp parallel for private(k, j, mw, sum) firstprivate(o, w) | 100 | ->inputs);
int h, j, k;
double *mw;
double sum;
if (!ann->hidden_layers) {
double *ret = o;
<LOOP-START>for (j = 0; j < ann->outputs; ++j) {
mw = w + ((ann->inputs + 1) * j);
sum = *mw++ * -1.0;
for (k = 0; k < ann->inputs; ++k) {
sum += *mw++ * i[k];
}
double output = genann_act_output(ann, ... |
Pmoonesi/multicore-processing-fcnn/phase1/genann_p.c | #pragma omp parallel for private(k, j, mw, sum) firstprivate(o, w) | 100 | genann_act_output(ann, sum);
*(o + j) = output;
}
return ret;
}
/* Figure input layer */
<LOOP-START>for (j = 0; j < ann->hidden; ++j) {
mw = w + ((ann->inputs + 1) * j);
sum = *mw++ * -1.0;
for (k = 0; k < ann->inputs; ++k) {
sum += *mw++ * i[k];
}
double output = genann_act_output(ann, sum);
... |
Pmoonesi/multicore-processing-fcnn/phase1/genann_p.c | #pragma omp parallel for private(k, j, mw, sum) firstprivate(o, w) | 100 | o += ann->hidden;
/* Figure hidden layers, if any. */
for (h = 1; h < ann->hidden_layers; ++h) {
<LOOP-START>for (j = 0; j < ann->hidden; ++j) {
mw = w + ((ann->hidden + 1) * j);
sum = *mw++ * -1.0;
for (k = 0; k < ann->hidden; ++k) {
sum += *mw++ * i[k];
}
double output = genann_act_output(ann, s... |
Pmoonesi/multicore-processing-fcnn/phase1/genann_p.c | #pragma omp parallel for private(k, j, mw, sum) firstprivate(o, w) | 100 | );
i += ann->hidden;
o += ann->hidden;
}
double const *ret = o;
/* Figure output layer. */
<LOOP-START>for (j = 0; j < ann->outputs; ++j) {
mw = w + ((ann->hidden + 1) * j);
sum = *mw++ * -1.0;
for (k = 0; k < ann->hidden; ++k) {
sum += *mw++ * i[k];
}
double output = genann_act_output(ann, sum);
... |
Pmoonesi/multicore-processing-fcnn/phase1/genann_p.c | #pragma omp parallel for firstprivate(d, t, o) private(j) | 100 | /
if (genann_act_output == genann_act_linear ||
ann->activation_output == genann_act_linear) {
<LOOP-START>for (j = 0; j < ann->outputs; ++j) {
*(d + j) = *(t + j) - *(o + j);
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(d, t, o) private(j)<OMP-END> |
Pmoonesi/multicore-processing-fcnn/phase1/genann_p.c | #pragma omp parallel for firstprivate(d, t, o) private(j) | 100 | te(j)
for (j = 0; j < ann->outputs; ++j) {
*(d + j) = *(t + j) - *(o + j);
}
}
else {
<LOOP-START>for (j = 0; j < ann->outputs; ++j) {
*(d + j) = (*(t + j) - *(o + j)) * *(o + j) * (1.0 - *(o + j));
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(d, t, o) private(j)<OMP-END> |
Pmoonesi/multicore-processing-fcnn/phase1/genann_p.c | #pragma omp parallel for private(j, k) firstprivate(o, d) | 100 | st ww = ann->weight + ((ann->inputs + 1) * ann->hidden) + ((ann->hidden + 1) * ann->hidden * (h));
<LOOP-START>for (j = 0; j < ann->hidden; ++j) {
double delta = 0;
for (k = 0; k < (h == ann->hidden_layers - 1 ? ann->outputs : ann->hidden); ++k) {
const double forward_delta = dd[k];
const int windex = ... |
Pmoonesi/multicore-processing-fcnn/phase1/genann_p.c | #pragma omp parallel for private(j, k) firstprivate(d, w) | 100 | ann->inputs + (ann->hidden) * (ann->hidden_layers - 1))
: 0);
/* Set output layer weights. */
<LOOP-START>for (j = 0; j < ann->outputs; ++j) {
double *mw = w + ((ann->hidden_layers ? ann->hidden : ann->inputs) + 1) * j;
*mw++ += *(d + j) * learning_rate * -1.0;
for (k = 1; k < (ann->hidden_layers ? ann->... |
Pmoonesi/multicore-processing-fcnn/phase1/genann_p.c | #pragma omp parallel for private(j, k) firstprivate(d, w) | 100 | + (h
? ((ann->inputs + 1) * ann->hidden + (ann->hidden + 1) * (ann->hidden) * (h - 1))
: 0);
<LOOP-START>for (j = 0; j < ann->hidden; ++j) {
double *mw = w + ((h == 0 ? ann->inputs : ann->hidden) + 1) * j;
*mw++ += *(d + j) * learning_rate * -1.0;
for (k = 1; k < (h == 0 ? ann->inputs : ann->hidden) + 1... |
Pmoonesi/multicore-processing-fcnn/phase2/genann_p.c | #pragma omp parallel for num_threads(8), private(k, j, mw, sum) firstprivate(o, w) | 100 | n->inputs);
int h, j, k;
double *mw;
double sum;
if (!ann->hidden_layers) {
double *ret = o;
<LOOP-START>for (j = 0; j < ann->outputs; ++j) {
mw = w + ((ann->inputs + 1) * j);
sum = *mw++ * -1.0;
for (k = 0; k < ann->inputs; ++k) {
sum += *mw++ * i[k];
}
double output = genann_act_output(ann, ... |
Pmoonesi/multicore-processing-fcnn/phase2/genann_p.c | #pragma omp parallel for num_threads(8), private(k, j, mw, sum) firstprivate(o, w) | 100 | genann_act_output(ann, sum);
*(o + j) = output;
}
return ret;
}
/* Figure input layer */
<LOOP-START>for (j = 0; j < ann->hidden; ++j) {
mw = w + ((ann->inputs + 1) * j);
sum = *mw++ * -1.0;
for (k = 0; k < ann->inputs; ++k) {
sum += *mw++ * i[k];
}
double output = genann_act_output(ann, sum);
... |
Pmoonesi/multicore-processing-fcnn/phase2/genann_p.c | #pragma omp parallel for num_threads(8), private(k, j, mw, sum) firstprivate(o, w) | 100 | o += ann->hidden;
/* Figure hidden layers, if any. */
for (h = 1; h < ann->hidden_layers; ++h) {
<LOOP-START>for (j = 0; j < ann->hidden; ++j) {
mw = w + ((ann->hidden + 1) * j);
sum = *mw++ * -1.0;
for (k = 0; k < ann->hidden; ++k) {
sum += *mw++ * i[k];
}
double output = genann_act_output(ann, s... |
Pmoonesi/multicore-processing-fcnn/phase2/genann_p.c | #pragma omp parallel for num_threads(8), private(k, j, mw, sum) firstprivate(o, w) | 100 | );
i += ann->hidden;
o += ann->hidden;
}
double const *ret = o;
/* Figure output layer. */
<LOOP-START>for (j = 0; j < ann->outputs; ++j) {
mw = w + ((ann->hidden + 1) * j);
sum = *mw++ * -1.0;
for (k = 0; k < ann->hidden; ++k) {
sum += *mw++ * i[k];
}
double output = genann_act_output(ann, sum);
... |
Pmoonesi/multicore-processing-fcnn/phase2/genann_p.c | #pragma omp parallel for firstprivate(d, t, o) private(j) | 100 | /
if (genann_act_output == genann_act_linear ||
ann->activation_output == genann_act_linear) {
<LOOP-START>for (j = 0; j < ann->outputs; ++j) {
*(d + j) = *(t + j) - *(o + j);
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(d, t, o) private(j)<OMP-END> |
Pmoonesi/multicore-processing-fcnn/phase2/genann_p.c | #pragma omp parallel for firstprivate(d, t, o) private(j) | 100 | te(j)
for (j = 0; j < ann->outputs; ++j) {
*(d + j) = *(t + j) - *(o + j);
}
}
else {
<LOOP-START>for (j = 0; j < ann->outputs; ++j) {
*(d + j) = (*(t + j) - *(o + j)) * *(o + j) * (1.0 - *(o + j));
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(d, t, o) private(j)<OMP-END> |
Pmoonesi/multicore-processing-fcnn/phase2/genann_p.c | #pragma omp parallel for private(j, k) firstprivate(o, d) | 100 | st ww = ann->weight + ((ann->inputs + 1) * ann->hidden) + ((ann->hidden + 1) * ann->hidden * (h));
<LOOP-START>for (j = 0; j < ann->hidden; ++j) {
double delta = 0;
for (k = 0; k < (h == ann->hidden_layers - 1 ? ann->outputs : ann->hidden); ++k) {
const double forward_delta = dd[k];
const int windex = ... |
Pmoonesi/multicore-processing-fcnn/phase2/genann_p.c | #pragma omp parallel for private(j, k) firstprivate(d, w) | 100 | ann->inputs + (ann->hidden) * (ann->hidden_layers - 1))
: 0);
/* Set output layer weights. */
<LOOP-START>for (j = 0; j < ann->outputs; ++j) {
double *mw = w + ((ann->hidden_layers ? ann->hidden : ann->inputs) + 1) * j;
*mw++ += *(d + j) * learning_rate * -1.0;
for (k = 1; k < (ann->hidden_layers ? ann->... |
Pmoonesi/multicore-processing-fcnn/phase2/genann_p.c | #pragma omp parallel for private(j, k) firstprivate(d, w) | 100 | + (h
? ((ann->inputs + 1) * ann->hidden + (ann->hidden + 1) * (ann->hidden) * (h - 1))
: 0);
<LOOP-START>for (j = 0; j < ann->hidden; ++j) {
double *mw = w + ((h == 0 ? ann->inputs : ann->hidden) + 1) * j;
*mw++ += *(d + 1) * learning_rate * -1.0;
for (k = 1; k < (h == 0 ? ann->inputs : ann->hidden) + 1... |
Pmoonesi/multicore-processing-fcnn/phase2/genann_p.c | #pragma omp parallel for | 100 | size * 10;
}
genann *save = genann_copy(ann);
/* Take a random guess at the ANN weights. */
<LOOP-START>for (i = 0; i < ann->total_weights; ++i) {
ann->weight[i] += ((double)rand()) / RAND_MAX - 0.5;
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END> |
Pmoonesi/multicore-processing-fcnn/phase2/genann_p.c | #pragma omp parallel for reduction(+:err) | 100 | ((double)rand()) / RAND_MAX - 0.5;
}
/* See how we did. */
err = 0;
int ind = 0, ans = 0;
<LOOP-START>for (i = 0; i < size; i++) {
const double *guess = genann_run(ann, inputs[i]);
err += genann_difference(guess, desired_outputs[i], 10);
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:err)... |
billDrett/GameOfLife-MPI-OpenMp-Cuda-/openMP/openmpMasterThreadCommunication/main.c | #pragma omp parallel for collapse(2) | 100 | neigbors
{
MPI_Start(&receiveReq[pos][i]);
}
//<LOOP-START>for(i = 2; i < nRows-2; i++) //calculate data inside the 2d array where we have all the data to find the new value of the cell
{
#pragma omp for
for(j = 2; j <nColum... |
billDrett/GameOfLife-MPI-OpenMp-Cuda-/openMP/openmpParrallelCommunication/main.c | #pragma omp parallel for collapse(2) | 100 | neigbors
{
MPI_Start(&receiveReq[pos][i]);
}
//<LOOP-START>for(i = 2; i < nRows-2; i++) //calculate data inside the 2d array where we have all the data to find the new value of the cell
{
#pragma omp for
for(j = 2; j <nColum... |
mperlet/matrix_multiplication/src/omp.c | #pragma omp parallel for | 100 | t_matrix->cols, sizeof(double));
// calculate the result matrix with omp (use pragma)
<LOOP-START>for (int i = 0; i < result_matrix->rows; i++) {
for (int j = 0; j < result_matrix->cols; j++) {
for (int k = 0; k < m_1->cols; k++) {
result_matrix->mat_data[i][j] += m_1->... |
vtsynergy/MetaMorph/metamorph-backends/openmp-backend/metamorph_openmp_mic.c | #pragma omp parallel for shared(n, data1, data2) private(i) reduction(+ : sum) | 100 | add_pd(
_mm256_add_pd(_mm256_add_pd(sum1, sum2), _mm256_add_pd(sum3, sum4)));
}
#else
<LOOP-START>for (i = 0; i < n; i++) {
sum += data1[i] * data2[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for shared(n, data1, data2) private(i) reduction(+ : sum)<OMP-END> |
vtsynergy/MetaMorph/metamorph-backends/openmp-backend/metamorph_openmp_mic.c | #pragma omp parallel for shared(n, data1, data2) private(i) reduction(+ : sum) | 100 | add_ps(
_mm256_add_ps(_mm256_add_ps(sum1, sum2), _mm256_add_ps(sum3, sum4)));
}
#else
<LOOP-START>for (i = 0; i < n; i++) {
sum += data1[i] * data2[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for shared(n, data1, data2) private(i) reduction(+ : sum)<OMP-END> |
vtsynergy/MetaMorph/metamorph-backends/openmp-backend/metamorph_openmp_mic.c | #pragma omp parallel for | 100 | i;
#ifdef USE_AVX
#pragma omp parallel shared(n, data1, data2) private(i) reduction(+ : sum)
{
<LOOP-START>for (i = 0; i < n; i++) {
sum += data1[i] * data2[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
vtsynergy/MetaMorph/metamorph-backends/openmp-backend/metamorph_openmp_mic.c | #pragma omp parallel for shared(n, data1, data2) private(i) reduction(+ : sum) | 100 | arallel for
for (i = 0; i < n; i++) {
sum += data1[i] * data2[i];
}
}
#else
<LOOP-START>for (i = 0; i < n; i++) {
sum += data1[i] * data2[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for shared(n, data1, data2) private(i) reduction(+ : sum)<OMP-END> |
vtsynergy/MetaMorph/metamorph-backends/openmp-backend/metamorph_openmp_mic.c | #pragma omp parallel for | 100 | i;
#ifdef USE_AVX
#pragma omp parallel shared(n, data1, data2) private(i) reduction(+ : sum)
{
<LOOP-START>for (i = 0; i < n; i++) {
sum += data1[i] * data2[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
vtsynergy/MetaMorph/metamorph-backends/openmp-backend/metamorph_openmp_mic.c | #pragma omp parallel for shared(n, data1, data2) private(i) reduction(+ : sum) | 100 | arallel for
for (i = 0; i < n; i++) {
sum += data1[i] * data2[i];
}
}
#else
<LOOP-START>for (i = 0; i < n; i++) {
sum += data1[i] * data2[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for shared(n, data1, data2) private(i) reduction(+ : sum)<OMP-END> |
vtsynergy/MetaMorph/metamorph-backends/openmp-backend/metamorph_openmp_mic.c | #pragma omp parallel for | 100 | i;
#ifdef USE_AVX
#pragma omp parallel shared(n, data1, data2) private(i) reduction(+ : sum)
{
<LOOP-START>for (i = 0; i < n; i++) {
sum += data1[i] * data2[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
vtsynergy/MetaMorph/metamorph-backends/openmp-backend/metamorph_openmp_mic.c | #pragma omp parallel for shared(n, data1, data2) private(i) reduction(+ : sum) | 100 | arallel for
for (i = 0; i < n; i++) {
sum += data1[i] * data2[i];
}
}
#else
<LOOP-START>for (i = 0; i < n; i++) {
sum += data1[i] * data2[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for shared(n, data1, data2) private(i) reduction(+ : sum)<OMP-END> |
vtsynergy/MetaMorph/metamorph-backends/openmp-backend/metamorph_openmp_mic.c | #pragma omp parallel for shared(n, data) private(i) reduction(+ : sum) | 100 | )
{
#pragma omp for
for (i = 0; i < n; i++) {
sum += data[i];
}
}
#else
<LOOP-START>for (i = 0; i < n; i++) {
sum += data[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for shared(n, data) private(i) reduction(+ : sum)<OMP-END> |
vtsynergy/MetaMorph/metamorph-backends/openmp-backend/metamorph_openmp_mic.c | #pragma omp parallel for shared(n, data) private(i) reduction(+ : sum) | 100 | )
{
#pragma omp for
for (i = 0; i < n; i++) {
sum += data[i];
}
}
#else
<LOOP-START>for (i = 0; i < n; i++) {
sum += data[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for shared(n, data) private(i) reduction(+ : sum)<OMP-END> |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.