source stringlengths 3 92 | c stringlengths 26 2.25M |
|---|---|
reduce.h | /******************************************************************************
* ** Copyright (c) 2016, Intel Corporation **
* ** All rights reserved. **
* ** ... |
scatter.h | #pragma once
#include <fstream>
#include <algorithm>
#include <cmath>
namespace Faunus {
/** @brief Routines related to scattering.
*/
namespace Scatter {
enum Algorithm { SIMD, EIGEN, GENERIC }; //!< Selections for math algorithms
/** @brief Form factor, `F(q)`, for a hard sphere of radius `R`.
*/
template <cla... |
cuBool_gpu.h | #ifndef cuBool_GPU_CUH
#define cuBool_GPU_CUH
#include <vector>
#include <iostream>
#include <sstream>
#include <limits>
#include <type_traits>
//#include <omp.h>
#include "helper/rngpu.h"
#include "helper/helpers.h"
#include "config.h" // WARPSPERBLOCK
#include "io_and_allocation.h"
#include "bit_vector_kernels.... |
Sema.h | //===--- Sema.h - Semantic Analysis & AST Building --------------*- 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
//
//===---------------------------... |
pscamax.c | /**
*
* @file
*
* PLASMA is a software package provided by:
* University of Tennessee, US,
* University of Manchester, UK.
*
* @generated from /home/luszczek/workspace/plasma/bitbucket/plasma/compute/pdzamax.c, normal z -> c, Fri Sep 28 17:38:10 2018
*
**/
#include "plasma_async.h"
#include "plasma_contex... |
psd.c | /*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% ... |
hash.c | //#if defined __INTEL_COMPILER
#include <stdio.h>
#define __USE_XOPEN
#include <stdlib.h>
#include "hash.h"
#include "genmalloc/genmalloc.h"
#ifdef HAVE_OPENCL
#include "hashlib_kern.inc"
#include "hashlib_source_kern.inc"
#endif
static ulong AA;
static ulong BB;
static ulong prime=4294967291;
static uint hashtablesi... |
parallelFileOp.h | #pragma once
#include<string>
#include<sstream>
#include<fstream>
#include<unordered_map>
#include<unordered_set>
#include<list>
#include<vector>
#include<functional>
// needed for posix io
#include<cstdio>
#include <sys/types.h>
#include <sys/stat.h>
#include<omp.h>
using std::string;
using std::stringstream;
using... |
for-5.c | /* { dg-additional-options "-std=gnu99" } */
extern void abort ();
#define M(x, y, z) O(x, y, z)
#define O(x, y, z) x ## _ ## y ## _ ## z
#pragma omp declare target
#define F for
#define G f
#define S
#define N(x) M(x, G, normal)
#include "for-2.h"
#undef S
#undef N
#undef F
#undef G
#pragma omp end declare target... |
mkldnn_graph.h | // Copyright (C) 2018-2019 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#pragma once
#include <map>
#include <string>
#include <vector>
#include <memory>
#include <cpp_interfaces/impl/ie_executable_network_thread_safe_default.hpp>
#include "ie_parallel.hpp"
#include "mkldnn_memory.h"
#include "config.... |
outer.c | /***********************************************************************
* Module: outer.c
*
* This module controls the outer iterations. Outer iterations are
* threaded over the energy dimension and represent a Jacobi iteration
* strategy. Includes setting the outer source. Checking outer iteration
* convergence... |
v2_cho.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <omp.h>
extern "C" void cholesky_dll(double *A, double *L, int n);
void gemm_ATA(double *A, double *C, int n) {
for(int i=0; i<n; i++) {
for(int j=0; j<n; j++) {
double sum = 0;
for(int k=0; k<n; k++) {
sum += A[i*n+... |
openmp.c | #include <stdio.h>
#include <omp.h>
// export OMP_NUM_THREADS=400
int main(int argc, char const *argv[]) {
int tid;
int gid = 1;
#pragma omp parallel private(tid) shared(gid) {
tid = omp_get_thread_num();
gid = tid;
printf("Hello world %d %d\n", tid, gid);
}
return 0;
}
|
convolution_sgemm_pack8_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 ... |
distort.c | /*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% ... |
Clustering.h | //
// Copyright (C) 2015 Yahoo Japan Corporation
//
// 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 la... |
GB_unaryop__abs_bool_int8.c | //------------------------------------------------------------------------------
// GB_unaryop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2019, All Rights Reserved.
// http... |
ClassicWots.h | #ifndef CLASSIC_WOTS
#define CLASSIC_WOTS
#include "primitives/AbstractDigest.h"
#include "utils/ByteArray.hpp"
#include <sstream>
#include <iostream>
#include <math.h>
template<class D, int W, class Enable = void>
class ClassicWots;
template <class D, int W>
class ClassicWots <D, W, typename std::enable_if<std::is_... |
QLA_D3_V_veq_Ma_times_V.c | /**************** QLA_D3_V_veq_Ma_times_V.c ********************/
#include <stdio.h>
#include <qla_config.h>
#include <qla_types.h>
#include <qla_random.h>
#include <qla_cmath.h>
#include <qla_d3.h>
#include <math.h>
static void start_slice(){
__asm__ __volatile__ ("");
}
static void end_slice(){
__asm__ __volat... |
utils.h | //
// Created by Viliam on 16.05.2018.
//
#ifndef SECONDREDUCEDUNIFORMBICUBICSPLINEINTERPOLATION_UTILS_H
#define SECONDREDUCEDUNIFORMBICUBICSPLINEINTERPOLATION_UTILS_H
#include <omp.h>
#include <thread>
#include <vector>
namespace utils
{
extern double DOUBLE_MIN;
extern unsigned int LOGICAL_THREAD_COUNT;
... |
kernel_reduction.h | // trueke //
// A multi-GPU implementation of the exchange Monte Carlo method. //
// //
///////////////////////////////////////////////////////////////////////... |
parallel_variable_transfer_utility.h | /*
==============================================================================
KratosStructuralApplication
A library based on:
Kratos
A General Purpose Software for Multi-Physics Finite Element Analysis
Version 1.0 (Released on march 05, 2007).
Copyright 2007
Pooyan Dadvand, Riccardo Rossi, Janosch Stascheit, Feli... |
GB_binop__ge_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-... |
stat_ops.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "stat_ops.h"
#include "utility.h"
#include "constant.h"
double expectation_value_X_Pauli_operator(UINT target_qubit_index, const CTYPE* state, ITYPE dim);
double expectation_value_Y_Pauli_operator(UINT target_qubit_index, const CTYPE... |
taskwait.c | // RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s
// REQUIRES: ompt
// UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7, gcc-8
#include "callback.h"
#include <omp.h>
int main()
{
int x = 0;
#pragma omp parallel num_threads(2)
{
#pragma omp master
{
#pragma omp task
{
x++;
}
... |
irbuilder_for_unsigned_down.c | // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --function-signature --include-generated-funcs
// RUN: %clang_cc1 -fopenmp-enable-irbuilder -verify -fopenmp -fopenmp-version=45 -x c++ -triple x86_64-unknown-unknown -emit-llvm %s -o - | FileCheck %s
// expected-no-diagnostics
#if... |
31548ff_so8_gcc_advfsg.c | #define _POSIX_C_SOURCE 200809L
#include "stdlib.h"
#include "math.h"
#include "sys/time.h"
#include "xmmintrin.h"
#include "pmmintrin.h"
#include "omp.h"
#include <stdio.h>
#define min(a, b) (((a) < (b)) ? (a) : (b))
#define max(a, b) (((a) > (b)) ? (a) : (b))
struct dataobj
{
void *restrict data;
int *size;
i... |
integrator.h | #ifndef _INTEGRATOR_H
#define _INTEGRATOR_H
#include <omp.h>
#include <optional>
#include "core.h"
#include "photon_map.h"
#include "scene.h"
class Integrator {
public:
// do preliminary jobs before calling integrate
virtual void build(const Scene& scene, Sampler& sampler) = 0;
// compute radiance coming fro... |
Tutorial.h | //=================================================================================================
/*!
// \file blaze/Tutorial.h
// \brief Tutorial of the Blaze library
//
// Copyright (C) 2012-2017 Klaus Iglberger - All Rights Reserved
//
// This file is part of the Blaze library. You can redistribute it and/or m... |
ast-dump-openmp-ordered.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_one() {
#pragma omp ordered
;
}
void test_two(int x) {
#pragma omp for ordered
for (int i = 0; i < x; i++)
;
}
void test_three(int x) {
#pragma omp f... |
GB_unaryop__ainv_int8_uint16.c | //------------------------------------------------------------------------------
// GB_unaryop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2019, All Rights Reserved.
// http... |
stream.c | /*-----------------------------------------------------------------------*/
/* Program: STREAM */
/* Revision: $Id: stream.c,v 5.10 2013/01/17 16:01:06 mccalpin Exp mccalpin $ */
/* Original code developed by John D. McCalpin */
/* Programm... |
omp_nested.c | /*
Test if the compiler support nested parallelism
By Chunhua Liao, University of Houston
Oct. 2005
*/
#include <stdio.h>
#include "omp.h"
#include "omp_testsuite.h"
int check_omp_nested( FILE *logFile)
{
int counter =0 ;
#ifdef _OPENMP
omp_set_nested(1);
#endif
#pragma omp parallel shared(counter)
{
#pragma omp... |
slantr.c | /**
*
* @file
*
* PLASMA is a software package provided by:
* University of Tennessee, US,
* University of Manchester, UK.
*
* @generated from /home/luszczek/workspace/plasma/bitbucket/plasma/compute/zlantr.c, normal z -> s, Fri Sep 28 17:38:08 2018
*
**/
#include "plasma.h"
#include "plasma_async.h"
#inc... |
info.c | // RUN: %libomptarget-compile-nvptx64-nvidia-cuda -gline-tables-only && env LIBOMPTARGET_INFO=23 %libomptarget-run-nvptx64-nvidia-cuda 2>&1 | %fcheck-nvptx64-nvidia-cuda -allow-empty -check-prefix=INFO
#include <stdio.h>
#include <omp.h>
#define N 64
int main() {
int A[N];
int B[N];
int C[N];
int val = 1;
/... |
program4.c | #include <omp.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
double random_double(){
return (random() / ((double)RAND_MAX + 1));
}
int main (int argc, char *argv[])
{
time_t t;
t = clock();
int w;
double pi;
double x, y;
double pInCircle;
double NUM_OF_SLAVES = 100;... |
GB_unaryop__minv_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... |
dependences.c | // RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s
// REQUIRES: ompt
// UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7
#include "callback.h"
#include <omp.h>
#include <math.h>
#include <unistd.h>
int main() {
int x = 0;
int condition=0;
#pragma omp parallel num_threads(2)
{
#pragma omp master
{
p... |
symv_x_dia_u_lo_conj.c | #include "alphasparse/kernel.h"
#include "alphasparse/opt.h"
#include "alphasparse/util.h"
#include <string.h>
#ifdef _OPENMP
#include <omp.h>
#endif
static alphasparse_status_t ONAME_omp(const ALPHA_Number alpha,
const ALPHA_SPMAT_DIA* A,
const ALPHA_Number* x,
const ALPHA_N... |
interaction_data.h | #pragma once
#include "optimized_bct_types.h"
namespace rsurfaces
{
struct InteractionData // Data structure for storing the sparse interaction matrices.
{ // To be owned only by instances of BlockClusterTree. Dunno how to design it such that it cannot b... |
GB_binop__pow_int8.c | //------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX-... |
AntOMP48.c | #include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<time.h>
#include<omp.h>
#include<mpi.h>
double dist[48][48];
double aleatorioEntero(int li, int ls);
double aleatorio();
int probabilidad(double visi[], double fero[], int vector[], int cities);
void gettingMatrix();
void pr... |
core.c | /* Main solver routines for heat equation solver */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <mpi.h>
#include "heat.h"
/* Exchange the boundary values */
void exchange(field *temperature, parallel_data *parallel, int thread_id)
{
int tag_up, tag_down;
tag_up = ... |
GB_unop__floor_fc64_fc64.c | //------------------------------------------------------------------------------
// GB_unop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX-Li... |
GB_binop__min_fp32.c | //------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2020, All Rights Reserved.
// http:... |
GB_unop__identity_uint8_int16.c | //------------------------------------------------------------------------------
// GB_unop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX-Li... |
declare_reduction_messages.c | // RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 100 %s -Wuninitialized
int temp; // expected-note 6 {{'temp' declared here}}
#pragma omp declare reduction // expected-error {{expected '(' afte... |
internal_variables_interpolation_process.h | // KRATOS __ __ _____ ____ _ _ ___ _ _ ____
// | \/ | ____/ ___|| | | |_ _| \ | |/ ___|
// | |\/| | _| \___ \| |_| || || \| | | _
// | | | | |___ ___) | _ || || |\ | |_| |
// |_| |_|_____|____/|_| |_|___|_| \_|\____| APPLICATION
//
// License: BSD License
// ... |
openmp_demo.c | //------------------------------------------------------------------------------
// GraphBLAS/Demo/Program/openmp_demo: example of user multithreading
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2022, All Rights Reserved.
// SPDX... |
GB_binop__land_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-... |
geopm_sched.c | /*
* Copyright (c) 2015 - 2022, Intel Corporation
* SPDX-License-Identifier: BSD-3-Clause
*/
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <stdint.h>
#include <unistd.h>
#include <pthread.h>
#include <errno.h>
#include <string.h>
#include "geopm_... |
clean_dist_3dfft.c | /*
* FFTX Copyright (c) 2020, The Regents of the University of California, through
* Lawrence Berkeley National Laboratory (subject to receipt of any required
* approvals from the U.S. Dept. of Energy), Carnegie Mellon University and
* SpiralGen, Inc. All rights reserved.
*
* If you have questions about your rig... |
game_of_life.c | #include <stdio.h>
#include <stdlib.h>
#include <omp.h>
#define N 2048
#define itera_max 2000
#define cores 1
int grid [N][N];
int new_grid[N][N];
void inicia_grids_zero(){
int i, j;
//iniciando com zero
#pragma omp parallel for collapse(2)
for (i = 0; i < N; i++){
for (j = 0; j < N; j++){
grid[i][j] = 0;
... |
GB_unop__log_fp64_fp64.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... |
atomic.c | #include <stdio.h>
#include <stdlib.h>
#include <omp.h>
main() {
float *x,*y,*work1,*work2;
float sum;
int *index;
int n,i;
n=1000;
x=(float*)malloc(n*sizeof(float));
y=(float*)malloc(n*sizeof(float));
work1=(float*)malloc(n*sizeof(float));
work2=(float*)malloc(n*sizeof(fl... |
sapH_fmt_plug.c | /*
* this is a SAP-H plugin for john the ripper.
* Copyright (c) 2014 JimF, 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.
*
* The internals of this algorithm were found on the HashCat ... |
NDArray.h | /*******************************************************************************
* Copyright (c) 2015-2018 Skymind, Inc.
*
* This program and the accompanying materials are made available under the
* terms of the Apache License, Version 2.0 which is available at
* https://www.apache.org/licenses/LICENSE-2.0.
*
*... |
GB_unaryop__ainv_fp32_uint32.c | //------------------------------------------------------------------------------
// GB_unaryop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2019, All Rights Reserved.
// http... |
CALPHADConcSolverBinary3Ph2Sl.h | #ifndef included_CALPHADConcSolverBinary3Ph2Sl
#define included_CALPHADConcSolverBinary3Ph2Sl
#include "NewtonSolver.h"
#include "datatypes.h"
namespace Thermo4PFM
{
class CALPHADConcSolverBinary3Ph2Sl
: public NewtonSolver<3, CALPHADConcSolverBinary3Ph2Sl, JacobianDataType>
{
public:
#ifdef HAVE_OPENMP_OFFLOAD
#... |
GB_unop_transpose.c | //------------------------------------------------------------------------------
// GB_unop_transpose: C=op(cast(A')), transpose, typecast, and apply op
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2022, All Rights Reserved.
// SP... |
GB_convert_sparse_to_bitmap_template.c | //------------------------------------------------------------------------------
// GB_convert_sparse_to_bitmap_template: convert A from sparse to bitmap
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// S... |
hllpp_omp.c | #include <limits.h>
#include <math.h>
#include <omp.h>
#include <stdio.h>
#include <stdlib.h>
#include "hllpp_omp.h"
#include "xxhash.h"
#define MAX(x, y) ((x) > (y) ? (x) : (y))
static uint8_t find_leftmost_one_position(uint64_t a, uint8_t offset);
double hllpp_omp(uint32_t *arr, size_t n, uint8_t end_of_buffer,
... |
GB_binop__lt_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-... |
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)
#... |
PmlFdtd.h | #pragma once
#include "Grid.h"
#include "FieldSolver.h"
#include "Fdtd.h"
#include "Pml.h"
namespace pfc {
class FDTD;
class PmlFdtd : public PmlReal<YeeGridType>
{
public:
PmlFdtd(FDTD * solver, Int3 sizePML) :
PmlReal((RealFieldSolver<YeeGridType>*)solver, sizePML) {}
void updateB();
void updateE();
... |
activation.h | // Copyright 2018 The MACE 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 appl... |
cache.c | /*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% ... |
DRB064-outeronly2-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__second_int8.c |
//------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2022, All Rights Reserved.
// SPDX... |
pi_omp_parallel.c | /*
* Compute pi by approximating the area under the curve f(x) = 4 / (1 + x*x)
* between 0 and 1.
*
* Parallel version using OpenMP
*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <omp.h> /* OpenMP */
double getusec_() {
struct timeval time;
gettimeofday(&time, NULL);
... |
bml_threshold_ellpack_typed.c | #include "../../macros.h"
#include "../../typed.h"
#include "../bml_allocate.h"
#include "../bml_parallel.h"
#include "../bml_threshold.h"
#include "../bml_types.h"
#include "bml_allocate_ellpack.h"
#include "bml_threshold_ellpack.h"
#include "bml_types_ellpack.h"
#include <complex.h>
#include <math.h>
#include <stdli... |
krb5pa-md5_fmt_plug.c | /*
* Kerberos 5 etype 23 "PA ENC TIMESTAMP" by magnum
*
* Previously called mskrb5 because I had the idea it was Micro$oft specific.
*
* Pcap file -> input file:
* 1. tshark -r capture.pcapng -T pdml > ~/capture.pdml
* 2. krbng2john.py ~/capture.pdml > krb5.in
* 3. Run john on krb5.in
*
* PA_DATA_ENC_TIMESTA... |
tqintf.h | //define PARALLEL 0 no loop with parallelization
//define PARALLEL 1 declared loops with parallelization
#define PARALLEL 1
#define OCVERSION "Open Calphad TQ v3.0 beta"
#define MAXEL 41
#define MAXPH 501
#define PHFIXED 2
#define PHENTERED 0
#define PHSUS -3
#define GRID 0
#define NOGRID -1
#define TCtoTK 273.15
#defi... |
program5.5.c | #include <stdlib.h>
#include <stdio.h>
#include <omp.h>
#include <time.h>
#include <malloc.h>
int main(int agrc, char* argv[]) {
int thread_count = strtol(argv[1], NULL, 10);
int n = strtol(argv[2], NULL, 10);
int* array = (int *)malloc(n * sizeof(int));
int temp;
double start, end;
srand(time... |
13_vector_dot_product.c | /*
Program : 13
Author : Debottam
Topic : Write a C program using Open MP features to find the dot
product of two vectors of size n each in constant time complexity.
[Hint: Dot product = Ʃ(A[i]*B[i])]
*/
#include <stdio.h>
#include <omp.h>
#define N 3
int main()
{
int A[]={3,-5,4},i;
... |
cache.c | /*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% ... |
detector_backup.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... |
graphutil.c | #include<stdio.h>
#include<sys/time.h>
#include "graph.h"
#include "graphutil.h"
#include "parsegraph.h"
graph* readGraph(const char* filename, const char* graphformat) {
struct timeval start, end;
gettimeofday(&start, NULL);
graph* G = parseedgeListGraph(filename, graphformat);
gettimeofday(&end, NULL);
pr... |
force.c |
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <omp.h>
#include <math.h>
#include "inc/ktime.h"
#include "inc/geometry.h"
#include "inc/ker/phy.h"
/* Calculates the forces (Drag FORCE, LIFT FORCE, and the momentum) */
void
compute_force(struct force *restrict f)
{
struct ktime ktime;
setktime... |
optimized.h | #include <structmember.h>
#include <omp.h>
#include <math.h>
/* For a given class cls and an attribute attr, defines a variable
attr_offset containing the offset of that attribute in the class's
__slots__ data structure. */
#define DECLARE_SLOT_OFFSET(attr,cls) \
PyMemberDescrObject *attr ## _descr = (PyMember... |
dposv.c | /**
*
* @file
*
* PLASMA is a software package provided by:
* University of Tennessee, US,
* University of Manchester, UK.
*
* @generated from /home/luszczek/workspace/plasma/bitbucket/plasma/compute/zposv.c, normal z -> d, Fri Sep 28 17:38:09 2018
*
**/
#include "plasma.h"
#include "plasma_async.h"
#incl... |
QLA_F3_V_vpeq_M_times_pV.c | /**************** QLA_F3_V_vpeq_M_times_pV.c ********************/
#include <stdio.h>
#include <qla_config.h>
#include <qla_types.h>
#include <qla_random.h>
#include <qla_cmath.h>
#include <qla_f3.h>
#include <math.h>
static void start_slice(){
__asm__ __volatile__ ("");
}
static void end_slice(){
__asm__ __vola... |
3d25pt.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-2, 3D 25 point stencil
* Adapted from PLUTO and Pochoir test bench
*
* Tar... |
menu.c | /* menu.c
* (c) 2002 Mikulas Patocka, Petr 'Brain' Kulhavy
* This file is a part of the Links program, released under GPL.
*/
#include "links.h"
static unsigned char * const version_texts[] = {
TEXT_(T_LINKS_VERSION),
TEXT_(T_OPERATING_SYSTEM_TYPE),
TEXT_(T_OPERATING_SYSTEM_VERSION),
TEXT_(T_COMPILER),
TEXT_... |
sudoku_solver_parallel_c.c | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <omp.h>
#define EMPTY 0
#define MAX_SIZE 25
int findEmptyLocation(int matrix[MAX_SIZE][MAX_SIZE], int *row, int *col, int box_size);
int canBeFilled(int matrix[MAX_SIZE][MAX_SIZE], int row, int col, int num, int box_size,... |
main.c | /*
* MIT License
*
* Copyright(c) 2011-2020 The Maintainers of Nanvix
*
* 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
* ... |
esac_util.h | /*
Based on the DSAC++ code.
Copyright (c) 2016, TU Dresden
Copyright (c) 2019, Heidelberg University
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... |
nonneg_lasso.c |
/******************************************************************************
* INCLUDES
*****************************************************************************/
#include "../admm.h"
/******************************************************************************
* PUBLIC FUNCTIONS
******************... |
convolution_5x5.h | // Tencent is pleased to support the open source community by making ncnn available.
//
// Copyright (C) 2017 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 ... |
snobal.h | /*
** NAME
** snobal.h
**
** DESCRIPTION
** Include file for the snobal library.
*/
#ifndef _SNOBAL_H_
#define _SNOBAL_H_
#include "types.h"
/*
* default for snowcover's maximum liquid h2o content as volume
* ratio: V_water/(V_snow - V_ice)
*/
#define DEFAULT_MAX_H2O_VOL 0.01
/*
* default fo... |
GB_unop__acosh_fp64_fp64.c | //------------------------------------------------------------------------------
// GB_unop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX-Li... |
main.c | #include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <omp.h>
#define NDEBUG
#ifndef NDEBUG
#define DEBUG(cmd) cmd;
#else
#define DEBUG(cmd) ;
#endif
// sin(x)_i = (-1)^i*x^(2i+1)/(2i+1)!
double get_element(double x, u_int64_t n, double prev)
{
if (n % 2 == 0)
{
return ... |
ParallelFor.h | /*
Bullet Continuous Collision Detection and Physics Library
Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/
This software is provided 'as-is', without any express or implied warranty.
In no event will the authors be held liable for any damages arising from the use of this software.
Permiss... |
ApproxWeightPerfectMatching.h | //
// ApproxWeightPerfectMatching.h
//
//
// Created by Ariful Azad on 8/22/17.
//
//
#ifndef ApproxWeightPerfectMatching_h
#define ApproxWeightPerfectMatching_h
#include "CombBLAS/CombBLAS.h"
#include "BPMaximalMatching.h"
#include "BPMaximumMatching.h"
#include <parallel/algorithm>
#include <parallel/numeric>
#... |
UMESimdVecIntPrototype.h | // The MIT License (MIT)
//
// Copyright (c) 2015-2017 CERN
//
// Author: Przemyslaw Karpinski
//
// 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 lim... |
utils.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__remainder_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... |
pi2.c | /*
* This code calculates pi using the formula to calculate
* the atan(z) which is the integral from 0 to z of 1/(1+x*x)
* times dx. atan(1) is 45 degrees or pi/4
*/
#include <stdio.h>
#include <omp.h>
static long num_steps = 100000; /* number of intervals */
double step; /* the size of the interval - dx */
... |
GB_unop.c | //------------------------------------------------------------------------------
// GB_unop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX-Li... |
add.h | #pragma once
#include <vector>
#include <unordered_map>
#include <algorithm>
#include <cmath>
#include <omp.h>
#include "_cuda.h"
using std::vector;
using std::unordered_map;
using std::max;
using std::abs;
// ADD-VALUE
// ---------
template <class T>
void addValue(T *a, int N, T v) {
for (int i=0; i<N; i++)
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.