source stringlengths 3 92 | c stringlengths 26 2.25M |
|---|---|
GB_unop__cos_fp64_fp64.c | //------------------------------------------------------------------------------
// GB_unop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2020, All Rights Reserved.
// http://... |
loop-collapse.c | /*
This implementation does some easy optimization on the baseline code.
*/
#include <omp.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#define L1 2000
#define L2 2000
#define LT 100
#define SEED 0
#define LS (L1 * L2)
int world[2][L1 + 2][L2 + 2];
double get_walltime() {
... |
pi_loop.c | /*
This program will numerically compute the integral of
4/(1+x*x)
from 0 to 1. The value of this integral is pi -- which
is great since it gives us an easy way to check the answer.
The program was parallelized using OpenMP by adding just
four lines
(1) A line to include omp... |
SPHCalcHydroForceFunctor.h | /**
* @file SPHCalcHydroForceFunctor.h
* @author seckler
* @date 22.01.18
*/
#pragma once
#include "autopas/autopasIncludes.h"
#include "autopas/sph/SPHKernels.h"
#include "autopas/sph/SPHParticle.h"
namespace autopas {
namespace sph {
/**
* Class that defines the hydrodynamic force functor.
* It is used to ca... |
particle_filter.c | /**
* @file ex_particle_OPENMP_seq.c
* @author Michael Trotter & Matt Goodrum
* @brief Particle filter implementation in C/OpenMP
*/
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <sys/time.h>
#include <omp.h>
#include <limits.h>
#include <string.h>
#include <time.h>
#define PI 3.1415926535897932... |
resample.c | /*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% ... |
GB_binop__bshift_uint16.c | //------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX-... |
rose_reduction.c | /*
* Test for automatic recognition of reduction variables
* */
#include "omp.h"
int a[100];
int sum;
void foo()
{
int i;
int sum2;
int xx;
int yy;
int zz;
sum = 0;
#pragma omp parallel for private (i) reduction (+:sum,xx) reduction (-:yy) reduction (*:zz)
for (i = 0; i <= 99; i += 1) {
a[i] =... |
6865.c | // this source is derived from CHILL AST originally from file '/uufs/chpc.utah.edu/common/home/u1142914/lib/ytopt_vinu/polybench/polybench-code/stencils/heat-3d/kernel.c' as parsed by frontend compiler rose
void kernel_heat_3d(int tsteps, int n, double A[120 + 0][120 + 0][120 + 0], double B[120 + 0][120 + 0][120 + 0])... |
GB_unaryop__abs_int32_fp32.c | //------------------------------------------------------------------------------
// GB_unaryop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2020, All Rights Reserved.
// http... |
zunmqr.c | /**
*
* @file
*
* PLASMA is a software package provided by:
* University of Tennessee, US,
* University of Manchester, UK.
*
* @precisions normal z -> s d c
*
**/
#include "plasma.h"
#include "plasma_async.h"
#include "plasma_context.h"
#include "plasma_descriptor.h"
#include "plasma_internal.h"
#include ... |
cnn_pool.h | #ifndef __CNN_POOL_H__
#define __CNN_POOL_H__
#include <string.h>
#include "cnn_types.h"
#ifdef CNN_WITH_CUDA
#include <cuda_runtime.h>
void cnn_pool_2d_max_gpu(float* dst, int* indexMat, int dstWidth, int dstHeight,
int poolSize, float* src, int srcWidth, int srcHeight,
... |
block-8.c | // { dg-do compile }
// PR 24451
int foo()
{
int i;
#pragma omp parallel for
for (i = 0; i < 10; ++i)
return 0; // { dg-error "invalid branch to/from OpenMP structured block" }
}
|
op_o.c | /*
* Compute a matrix representation of the operator
*
* O(.)=A(inv(Z)*A'(.)*X)
*
* The ith colum of the result is O(e_i), where e_i is the vector with a 1 in
* position i and 0's elsewhere.
*
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#ifdef USEOPENMP
#include <omp.h>
#endif
#include "d... |
GB_binop__lt_uint64.c |
//------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX... |
photonmap_sample.h | #pragma once
// Copyright (c) 2014 hole
// This software is released under the MIT License (http://kagamin.net/hole/license.txt).
// A part of this software is based on smallpt (http://www.kevinbeason.com/smallpt/) and
// released under the MIT License (http://kagamin.net/hole/smallpt-license.txt).
#include <algorithm... |
taskdep_taskwait_tied_scheduling.c | // RUN: %libomp-compile && env KMP_ABT_NUM_ESS=4 %libomp-run
// REQUIRES: abt
#include "omp_testsuite.h"
#include "bolt_scheduling_util.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int calc_seq(int n) {
int i, j, *buffer = (int *)malloc(sizeof(int) * n * n);
for (i = 0; i < n; i++) {
for (j = ... |
3d7pt_var.c | /*
* Order-1, 3D 7 point stencil with variable coefficients
* Adapted from PLUTO and Pochoir test bench
*
* Tareq Malas
*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#ifdef LIKWID_PERFMON
#include <likwid.h>
#endif
#include "print_utils.h"
#define TESTS 2
#define MAX(a,b) ((a) > (b) ? a : b)
#... |
riemann.c | /*
Authors:
Takeshi I.
*/
#include <math.h>
#include <omp.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <time.h>
#define PI 3.14159265
/*
Define func as a function type that takes
a double and returns a double.
*/
typedef double (*func)(double);
/* Calculates... |
comm.h | /*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you ... |
model.h | /*****************************************************************************/
// Copyright (c) 2020-2021 Yuji KOGUMA
// Released under the MIT license
// https://opensource.org/licenses/mit-license.php
/*****************************************************************************/
#ifndef PRINTEMPS_MODEL_MODEL_H__
#d... |
convolution_5x5_pack4.h | // Tencent is pleased to support the open source community by making ncnn available.
//
// Copyright (C) 2019 THL A29 Limited, a Tencent company. All rights reserved.
//
// Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a ... |
ZQ_CNN_MTCNN.h | #ifndef _ZQ_CNN_MTCNN_H_
#define _ZQ_CNN_MTCNN_H_
#pragma once
#include "ZQ_CNN_Net.h"
#include "ZQ_CNN_BBoxUtils.h"
#include <omp.h>
namespace ZQ
{
class ZQ_CNN_MTCNN
{
public:
using string = std::string;
ZQ_CNN_MTCNN()
{
min_size = 60;
thresh[0] = 0.6;
thresh[1] = 0.7;
thresh[2] = 0.7;
nms_thr... |
3d25pt.c | /*
* Order-2, 3D 25 point stencil
* Adapted from PLUTO and Pochoir test bench
*
* Tareq Malas
*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#ifdef LIKWID_PERFMON
#include <likwid.h>
#endif
#include "print_utils.h"
#define TESTS 2
#define MAX(a,b) ((a) > (b) ? a : b)
#define MIN(a,b) ((a) < (b)... |
profile.c | /*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% ... |
updater_basemaker-inl.h | /*!
* Copyright 2014 by Contributors
* \file updater_basemaker-inl.h
* \brief implement a common tree constructor
* \author Tianqi Chen
*/
#ifndef XGBOOST_TREE_UPDATER_BASEMAKER_INL_H_
#define XGBOOST_TREE_UPDATER_BASEMAKER_INL_H_
#include <rabit/rabit.h>
#include <vector>
#include <algorithm>
#include <string>... |
ast-dump-openmp-taskwait.c | // RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
void test(void) {
#pragma omp taskwait
}
// CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
// CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-tas... |
omp_parallel_for_ordered.c | // RUN: %libomp-compile-and-run
#include <stdio.h>
#include "omp_testsuite.h"
static int last_i = 0;
int i;
#pragma omp threadprivate(i)
/* Variable ii is used to avoid problems with a threadprivate variable used as a loop
* index. See test omp_threadprivate_for.
*/
static int ii;
#pragma omp threadprivate(ii)
/*... |
master_taskloop_simd_misc_messages.c | // RUN: %clang_cc1 -fsyntax-only -fopenmp -triple x86_64-unknown-unknown -verify %s -Wuninitialized
// RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -triple x86_64-unknown-unknown -verify %s -Wuninitialized
void xxx(int argc) {
int x; // expected-note {{initialize the variable 'x' to silence this warning}}
#pragma om... |
distribute.c | #include <stdio.h>
#include <omp.h>
/* This program does not work, because I am not using distribute properly. */
int main(int argc, char* argv[])
{
#ifdef DISTRIBUTE
#pragma omp distribute parallel for
#else
#pragma omp parallel for
#endif
for (int i=0; i<100; i++) {
printf("tid=%d\n", omp_get_thread_num... |
bench.c | #include "ghost/util.h"
#include "ghost/machine.h"
#include "ghost/bench.h"
#include "ghost/task.h"
#include "ghost/timing.h"
#include "ghost/cu_bench.h"
#ifndef __FUJITSU
#include <immintrin.h>
#endif
#ifdef GHOST_BUILD_MIC
#ifdef GHOST_BUILD_AVX512
#define MIC_STREAMINGSTORE _mm512_stream_pd
#else
#define MIC_STREA... |
sse.h | /* SPDX-License-Identifier: MIT
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy,
* modify, merge, publish, ... |
kdtree.c | /** @file kdtree.c
** @brief KD-tree - Definition
** @author Andrea Vedaldi, David Novotny
**/
/*
Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson.
All rights reserved.
This file is part of the VLFeat library and is made available under
the terms of the BSD license (see the COPYING file).
*/
/**
<!-- ~~~... |
firstprivate.c | #include <stdio.h>
#include <stdlib.h>
#define TRUE 1
#define FALSE 0
#ifdef _OPENMP
#include <omp.h>
#else
#define omp_get_thread_num() 0
#define omp_get_num_threads() 1
#endif
int main()
{
#ifdef _OPENMP
(void) omp_set_dynamic(FALSE);
if (omp_get_dynamic()) {printf("Advertencia: se ha hecho el ajust... |
omp50_taskdep_depobj.c | // RUN: %clang %openmp_flags %flags-use-compiler-omp-h %s -o %t && %libomp-run
// UNSUPPORTED: gcc-5, gcc-6, gcc-7, gcc-8
// UNSUPPORTED: clang-5, clang-6, clang-7, clang-8, clang-9, clang-10
// UNSUPPORTED: icc
#include <stdio.h>
#include <stdlib.h>
#include <omp.h>
#include "omp_my_sleep.h"
int a, b;
void mutexino... |
DRB059-lastprivate-orig-no.c | /*
Copyright (c) 2017, Lawrence Livermore National Security, LLC.
Produced at the Lawrence Livermore National Laboratory
Written by Chunhua Liao, Pei-Hung Lin, Joshua Asplund,
Markus Schordan, and Ian Karlin
(email: liao6@llnl.gov, lin32@llnl.gov, asplund1@llnl.gov,
schordan1@llnl.gov, karlin1@llnl.gov)
LLNL-CODE-73214... |
GB_binop__bshift_int64.c | //------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX-... |
GB_unaryop__ainv_uint16_bool.c | //------------------------------------------------------------------------------
// GB_unaryop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2020, All Rights Reserved.
// http... |
3d7pt.lbpar.c | #include <omp.h>
#include <math.h>
#define ceild(n,d) ceil(((double)(n))/((double)(d)))
#define floord(n,d) floor(((double)(n))/((double)(d)))
#define max(x,y) ((x) > (y)? (x) : (y))
#define min(x,y) ((x) < (y)? (x) : (y))
/*
* Order-1, 3D 7 point stencil
* Adapted from PLUTO and Pochoir test bench
*
* Tare... |
store.c | #include <string.h>
#include <mpi.h>
#include <pfft.h>
#include <gsl/gsl_rng.h>
#include <fastpm/libfastpm.h>
#include <fastpm/logging.h>
#include "pmpfft.h"
#define HAS(a, b) ((a & b) != 0)
static void
pack_any(FastPMStore * p, ptrdiff_t index, int ci, void * packed)
{
size_t elsize = p->_column_info[ci].elsiz... |
blackscholes.c | // Copyright (c) 2007 Intel Corp.
// Black-Scholes
// Analytical method for calculating European Options
//
//
// Reference Source: Options, Futures, and Other Derivatives, 3rd Edition, Prentice
// Hall, John C. Hull,
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#ifdef ENABLE_PARSEC... |
nanort.h | //
// NanoRT, single header only modern ray tracing kernel.
//
//
// Notes : The number of primitives are up to 2G. If you want to render large
// data, please split data into chunks(~ 2G prims) and use NanoSG scene graph
// library(`${nanort}/examples/nanosg`).
//
/*
The MIT License (MIT)
Copyright (c) 2015 - 2018 ... |
boson_basis_core.h | #ifndef _BOSON_BASIS_CORE_H
#define _BOSON_BASIS_CORE_H
#include <complex>
#include <cmath>
#include "general_basis_core.h"
#include "numpy/ndarraytypes.h"
#include "openmp.h"
namespace basis_general {
template<class I>
I inline boson_map_bits(I s,const int map[],const I M[],const int sps,const int N){
I ss = 0;
... |
GB_binop__isgt_uint64.c |
//------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2022, All Rights Reserved.
// SPDX... |
pr49898-2.c | /* PR middle-end/49898 */
/* { dg-do run } */
extern void abort (void);
int
main ()
{
int i, j, sum = 0;
#pragma omp parallel for reduction(+:sum)
for (i = 0; i < 10; i++)
#pragma omp parallel for reduction(+:sum)
for (j = 0; j < 10; j++)
sum += j;
if (sum != 450)
abort ();
return 0;
}
|
vect-simd-clone-10.h | #pragma omp declare simd notinbranch
extern int foo (long int a, int b, int c);
#pragma omp declare simd notinbranch
extern long int bar (int a, int b, long int c);
|
paraGraph.h | #ifndef __PARAGRAPH_H__
#define __PARAGRAPH_H__
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <omp.h>
#include "vertex_set.h"
#include "graph.h"
#include "mic.h"
#define V_RATIO 10
#define E_RATIO 5
// count the number of outgoing edges in parallel
// potentially useful f... |
batchnorm_ref.c | /*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* License); you ma... |
GB_binop__islt_fp32.c |
//------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2022, All Rights Reserved.
// SPDX... |
GB_unop__erf_fp32_fp32.c | //------------------------------------------------------------------------------
// GB_unop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2022, All Rights Reserved.
// SPDX-Li... |
rose_doall.c | #include "omp.h"
void foo()
{
int i;
int a[100];
#pragma omp parallel for private (i)
for (i = 0; i <= 99; i += 1) {
a[i] = a[i] + 1;
}
}
/*
* ..= a[i]+1 // read
* a[i] == // write
* non-loop carried anti-dependence : Write-after-Read
*
dep SgExprStatement:a[i] =((a[i]) + 1);
SgExprStat... |
residualbased_predictorcorrector_velocity_bossak_ale_scheme.h | // | / |
// ' / __| _` | __| _ \ __|
// . \ | ( | | ( |\__ `
// _|\_\_| \__,_|\__|\___/ ____/
// Multi-Physics
//
// License: BSD License
// Kratos default license: kratos/license.txt
//
// Main authors: Ignasi de Pouplana
// Miguel Ma... |
Parser.h | //===--- Parser.h - C Language Parser ---------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===---------------------------... |
rawMD5_fmt_plug.c | /*
* Raw-MD5 (thick) based on Raw-MD4 w/ mmx/sse/intrinsics
* This software is Copyright (c) 2011 magnum, and it is hereby released to the
* general public under the following terms: Redistribution and use in source
* and binary forms, with or without modification, are permitted.
*
* OMP added May 2013, JimF
* ... |
GB_binop__iseq_fp64.c | //------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX-... |
sssp.h | #include <limits.h>
node_t root;
uint32_t* dist;
#define NUM_LOCKS 16
#define LOCK_SHIFT (28)
void outputsssp(graph *G) {
int counter = 0;
printf("The shortest path to the following nodes from the root Node %d\n", root);
for (node_t n = 0; n < G->numNodes && counter < 5; n++) {
if(dist[n] != UI... |
GB_unop__tan_fp32_fp32.c | //------------------------------------------------------------------------------
// GB_unop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2022, All Rights Reserved.
// SPDX-Li... |
hierarchical_sne_inl.h | /*
*
* Copyright (c) 2014, Nicola Pezzotti (Delft University of Technology)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* 1. Redistributions of source code must retain the above ... |
ublas_space.h | // | / |
// ' / __| _` | __| _ \ __|
// . \ | ( | | ( |\__ `
// _|\_\_| \__,_|\__|\___/ ____/
// Multi-Physics
//
// License: BSD License
// Kratos default license: kratos/license.txt
//
// Main authors: Riccardo Rossi
// Collaborator: Vicente Matai... |
nestedSIMD.c | #include <stdio.h>
#define N 3
#define M 4
int main()
{
int a[N][M];
int i,ii, error = 0;
// initialize
for(i=0; i<N; i++)
for(ii=0; ii<M; ii++)
a[i][ii] = -1;
// offload
#pragma omp target map(tofrom: a[0:3][0:4])
{
int k,j;
#pragma omp simd
for(k=0; k<N; k++) {
a[k][0] =... |
particlefilter.c | /**
* @file ex_particle_OPENMP_seq.c
* @author Michael Trotter & Matt Goodrum
* @brief Particle filter implementation in C/OpenMP
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <sys/time.h>
#include <time.h>
// RISC-V VECTOR Version by Cristóbal Ramírez Lazo, "... |
karniadakis.h | #ifndef _TL_KARNIADAKIS_
#define _TL_KARNIADAKIS_
#include <array>
#include "matrix.h"
#include "matrix_array.h"
#include "quadmat.h"
namespace spectral{
/*! @brief Kinds of Stepper coefficients for karniadakis scheme
* @ingroup algorithms
*/
enum stepper { TL_EULER, //!< Euler scheme (use for 1st step)
... |
AllSimplePaths.h | /*
* AllSimplePaths.h
*
* Created on: 23.06.2017
* Author: Eugenio Angriman
*/
#ifndef AllSimplePaths_H_
#define AllSimplePaths_H_
#include "../graph/Graph.h"
#include "../base/Algorithm.h"
namespace NetworKit {
/**
* @ingroup distance
* Determines all the possible simple paths from a given source node ... |
Transform.c | /*
* $Id: Transform.c,v 1.58 2008-05-14 23:19:24 dbrown Exp $
*/
/************************************************************************
* *
* Copyright (C) 1992 *
* University Corporation for Atmospheric Research *
* All Rights Reserved *
* *
**************************... |
hybrid-hello.c | /*
Copyright 2012 Intel Corporation. All Rights Reserved.
The source code contained or described herein and all documents
related to the source code ("Material") are owned by Intel Corporation
or its suppliers or licensors. Title to the Material remains with
Intel Corporation or its suppliers and... |
csr_graph.h | #pragma once
#include <cassert>
#include <fstream>
#include <sstream>
#include <fcntl.h>
#include <iostream>
#include <unistd.h>
#include <algorithm>
#include <sys/mman.h>
#include "common.h"
#include "custom_alloc.h"
class VertexSet {
private:
VertexId *ptr;
VertexId size_;
public:
VertexSet() : size_(0) {}
V... |
1846.c | /* POLYBENCH/GPU-OPENMP
*
* This file is a part of the Polybench/GPU-OpenMP suite
*
* Contact:
* William Killian <killian@udel.edu>
*
* Copyright 2013, The University of Delaware
*/
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <math.h>
/* Include polybench common header. */
#include <po... |
GB_binop__div_fc32.c | //------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX-... |
regression_tree.h | /*
Copyright (c) 2016, TU Dresden
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the... |
mxnet_op.h | /*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you ... |
GB_binop__times_uint8.c | //------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX-... |
common.h | #ifndef LIGHTGBM_UTILS_COMMON_FUN_H_
#define LIGHTGBM_UTILS_COMMON_FUN_H_
#include <LightGBM/utils/log.h>
#include <LightGBM/utils/openmp_wrapper.h>
#include <cstdio>
#include <string>
#include <vector>
#include <sstream>
#include <cstdint>
#include <algorithm>
#include <cmath>
#include <functional>
#include <memory>... |
crypt-sha1_fmt_plug.c | /*
* This file is based on the "cryptsha512_fmt_plug.c" file.
*
* This software is Copyright (c) 2014 Dhiru Kholia, and it is hereby released
* to the general public under the following terms:
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted.
*
* Enhanced cod... |
vadd.c | #include <stdint.h>
#include <stdio.h>
#include <omp.h>
void vadd (uint64_t *a, uint64_t *b, uint64_t *c, uint64_t vecLen, uint64_t *result) {
#pragma omp target
{
uint64_t act_sum = 0;
#pragma omp parallel for reduction(+:act_sum)
for (uint64_t i = 0; i < vecLen; i++) {
uint64_t sum ... |
GrB_IndexUnaryOp_wait.c | //------------------------------------------------------------------------------
// GrB_IndexUnaryOp_wait: wait for a user-defined GrB_IndexUnaryOp to complete
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved... |
omp_task_priority2.c | // RUN: %libomp-compile && env OMP_MAX_TASK_PRIORITY='2' %libomp-run
// Test OMP 4.5 task priorities
// Higher priority task supposed to be executed before lower priority task.
#include <stdio.h>
#include <omp.h>
#include "omp_my_sleep.h"
// delay(n) - sleep n ms
#define delay(n) my_sleep(((double)n)/1000.0)
int ma... |
enhance.c | /*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% ... |
fox_floats_timer_caching_omp_fileIO_benchmark.c | /* fox_floats_timer_caching_omp_fileIO_benchmark.c -- uses Fox's algorithm to multiply two square matrices
*
* Implementation of parallel matrix multiplication:
* LaTeX: $C_{i,j} = \sum_{k} A_{i,k}B_{k,j}$
*
* Input:
* Input Matrix file name: A.dat, B.dat
*
* Output:
* Output Matrix file name: C.dat... |
__clang_cuda_libdevice_declares.h | /*===-- __clang_cuda_libdevice_declares.h - decls for libdevice functions --===
*
* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
* See https://llvm.org/LICENSE.txt for license information.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*
*===----------------------------... |
GB_binop__iseq_uint32.c | //------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX-... |
vector.h | /*
Copyright (c) 2020, VSB - Technical University of Ostrava and Graz University of
Technology
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyr... |
gaussian_cwa_smd.h | #ifndef METHODS_GAUSSIAN_CWA_SMD_H
#define METHODS_GAUSSIAN_CWA_SMD_H
namespace method {
namespace g_cwa_smd {
namespace details {
template<typename Function>
auto expectation(const Function & function,
const arma::mat & points,
const arma::vec & weights) {
auto result = at(functi... |
target.c | int main(int argc, char* argv[])
{
int i;
int len = 1000;
int a[1000];
for (i=0; i<len; i++)
a[i]= i;
#pragma omp target if(target:test)
#pragma omp parallel for
for (i=0;i< len -1 ;i++)
a[i]=a[i]+1;
return 0;
}
|
KPP_Global.h | /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
/* */
/* Global Data Header File */
/* */
/* Generated by KPP-2.2.3 symbolic ... |
clauses-2.c | struct S { int r; int *s; int t[10]; };
void bar (int *);
void
foo (int *p, int q, struct S t, int i, int j, int k, int l)
{
#pragma omp target map (q), firstprivate (q) /* { dg-error "appears both in data and map clauses" } */
bar (&q);
#pragma omp target map (p[0]) firstprivate (p) /* { dg-error "appears mor... |
prog5.2.c | #include <stdio.h>
#include <stdlib.h>
#include <omp.h>
#include <time.h>
long long int monte_carlo();
int main(int argc, char *argv[])
{
long long int total_number_of_toss = strtol(argv[1], NULL, 10);
long long int total_number_in_circle = 0;
int thread_count = strtol(argv[2], NULL, 10);
srand(time(... |
detector.c | #include "darknet.h"
static int coco_ids[] = {1,2,3,4,5,6,7,8,9,10,11,13,14,15,16,17,18,19,20,21,22,23,24,25,27,28,31,32,33,34,35,36,37,38,39,40,41,42,43,44,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,67,70,72,73,74,75,76,77,78,79,80,81,82,84,85,86,87,88,89,90};
void train_detector(char *datacfg, cha... |
common_main.h | #ifndef COMMON_MAIN_H
#define COMMON_MAIN_H
#include <omp.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/time.h>
#include "gm.h"
#include <pthread.h>
class main_t
{
protected:
gm_graph G;
int num_threads;
bool is_all_thread_mode() {return num_threads == -1;}
public:
main_t() {time_to_e... |
PeptideIndexing.h | // --------------------------------------------------------------------------
// OpenMS -- Open-Source Mass Spectrometry
// --------------------------------------------------------------------------
// Copyright The OpenMS Team -- Eberhard Karls University Tuebingen,
// ETH Zurich, and Freie Universit... |
gm_bfs_template.h | #ifndef GM_BFS_TEMPLATE_H
#define GM_BFS_TEMPLATE_H
#include <omp.h>
#include <string.h>
#include <map>
#include <set>
#include "gm_graph.h"
#include "gm_atomic_wrapper.h"
#include "gm_bitmap.h"
// todo: consideration for non small-world graph
template<typename level_t, bool use_multithread, bool has_navigator, bool... |
GB_binop__div_int16.c |
//------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2022, All Rights Reserved.
// SPDX... |
deconvolution_packnto1_fp16s.h | // Tencent is pleased to support the open source community by making ncnn available.
//
// Copyright (C) 2021 THL A29 Limited, a Tencent company. All rights reserved.
//
// Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy ... |
GB_unaryop__minv_uint8_fp32.c | //------------------------------------------------------------------------------
// GB_unaryop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2019, All Rights Reserved.
// http... |
master.c | #include <stdio.h>
#include <stdlib.h>
#include <omp.h>
main(int argc, char **argv){
int i, n=20, tid, a[n],suma=0,sumalocal;
if(argc<2){
fprintf(stderr,"\nFalta iteraciones\n");
exit(-1);
}
n=atoi(argv[1]); if (n>20) n=20;
for(i=0;i<n;i++) a[i]=i;
#pragma omp parallel private(sumalocal,tid... |
a.16.1.c | /* { dg-do run } */
#include <stdio.h>
float
work1 (int i)
{
return 1.0 * i;
}
float
work2 (int i)
{
return 2.0 * i;
}
void
a16 (float *x, float *y, int *index, int n)
{
int i;
#pragma omp parallel for shared(x, y, index, n)
for (i = 0; i < n; i++)
{
#pragma omp atomic
x[index[i]] += work1 (i);
... |
GB_unop__atan_fc64_fc64.c | //------------------------------------------------------------------------------
// GB_unop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2022, All Rights Reserved.
// SPDX-Li... |
cgmtest.c | #include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <CL/cl.h>
//#include <omp.h>
#define BUF_SIZE 1024
#define print_error(format, ...) { \
fprintf (stderr, "[%s:%d in %s]... |
mkl_util.h | /* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or a... |
eavlInfoTopologyScatterMapOp.h | // Copyright 2010-2014 UT-Battelle, LLC. See LICENSE.txt for more information.
#ifndef EAVL_INFO_TOPOLOGY_SCATTER_MAP_OP_H
#define EAVL_INFO_TOPOLOGY_SCATTER_MAP_OP_H
#include "eavlCUDA.h"
#include "eavlCellSet.h"
#include "eavlCellSetExplicit.h"
#include "eavlCellSetAllStructured.h"
#include "eavlDataSet.h"
#include... |
sageInterface.h | #ifndef ROSE_SAGE_INTERFACE
#define ROSE_SAGE_INTERFACE
#include "sage3basic.hhh"
#include <stdint.h>
#include <utility>
#include "rosePublicConfig.h" // for ROSE_BUILD_JAVA_LANGUAGE_SUPPORT
#if 0 // FMZ(07/07/2010): the argument "nextErrorCode" should be call-by-reference
SgFile* determineFileType ( std::vector<s... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.