1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
/*******************************************************************************
* Copyright 2018 Intel 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 law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*******************************************************************************/
#include <string.h>
#ifdef _WIN32
#include <malloc.h>
#include <windows.h>
#endif
#include <limits.h>
#include <stdlib.h>
#include <stdio.h>
#include "mkldnn.h"
#include "utils.hpp"
namespace mkldnn {
namespace impl {
int getenv(const char *name, char *buffer, int buffer_size) {
if (name == NULL || buffer_size < 0 || (buffer == NULL && buffer_size > 0))
return INT_MIN;
int result = 0;
int term_zero_idx = 0;
size_t value_length = 0;
#ifdef _WIN32
value_length = GetEnvironmentVariable(name, buffer, buffer_size);
#else
const char *value = ::getenv(name);
value_length = value == NULL ? 0 : strlen(value);
#endif
if (value_length > INT_MAX)
result = INT_MIN;
else {
int int_value_length = (int)value_length;
if (int_value_length >= buffer_size) {
result = -int_value_length;
} else {
term_zero_idx = int_value_length;
result = int_value_length;
#ifndef _WIN32
strncpy(buffer, value, value_length);
#endif
}
}
if (buffer != NULL)
buffer[term_zero_idx] = '\0';
return result;
}
int getenv_int(const char *name, int default_value)
{
int value = default_value;
// # of digits in the longest 32-bit signed int + sign + terminating null
const int len = 12;
char value_str[len];
if (getenv(name, value_str, len) > 0)
value = atoi(value_str);
return value;
}
FILE *fopen(const char *filename, const char *mode) {
#ifdef _WIN32
FILE *fp = NULL;
return ::fopen_s(&fp, filename, mode) ? NULL : fp;
#else
return ::fopen(filename, mode);
#endif
}
void *malloc(size_t size, int alignment) {
void *ptr;
#ifdef _WIN32
ptr = _aligned_malloc(size, alignment);
int rc = ptr ? 0 : -1;
#else
int rc = ::posix_memalign(&ptr, alignment, size);
#endif
return (rc == 0) ? ptr : 0;
}
void free(void *p) {
#ifdef _WIN32
_aligned_free(p);
#else
::free(p);
#endif
}
// Atomic operations
int32_t fetch_and_add(int32_t *dst, int32_t val) {
#ifdef _WIN32
return InterlockedExchangeAdd(reinterpret_cast<long*>(dst), val);
#else
return __sync_fetch_and_add(dst, val);
#endif
}
static int jit_dump_flag = 0;
static bool jit_dump_flag_initialized = false;
bool jit_dump_enabled() {
if (!jit_dump_flag_initialized) {
jit_dump_flag = getenv_int("MKLDNN_JIT_DUMP");
jit_dump_flag_initialized = true;
}
return jit_dump_flag != 0;
}
}
}
mkldnn_status_t mkldnn_set_jit_dump(int enabled) {
using namespace mkldnn::impl::status;
mkldnn::impl::jit_dump_flag = enabled;
mkldnn::impl::jit_dump_flag_initialized = true;
return success;
}
|