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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
/* Copyright 2016 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 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.
==============================================================================*/
#ifdef TENSORFLOW_USE_JEMALLOC
#include "jemalloc/jemalloc.h"
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef SNAPPY
#include "snappy.h"
#endif
#include <Windows.h>
#include "tensorflow/core/platform/cpu_info.h"
#include "tensorflow/core/platform/demangle.h"
#include "tensorflow/core/platform/host_info.h"
#include "tensorflow/core/platform/init_main.h"
#include "tensorflow/core/platform/logging.h"
#include "tensorflow/core/platform/mem.h"
#include "tensorflow/core/platform/snappy.h"
#include "tensorflow/core/platform/types.h"
namespace tensorflow {
namespace port {
void InitMain(const char* usage, int* argc, char*** argv) {}
string Hostname() {
char name[1024];
DWORD name_size = sizeof(name);
name[0] = 0;
if (::GetComputerNameA(name, &name_size)) {
name[name_size] = 0;
}
return name;
}
int NumSchedulableCPUs() {
SYSTEM_INFO system_info;
GetSystemInfo(&system_info);
return system_info.dwNumberOfProcessors;
}
void* AlignedMalloc(size_t size, int minimum_alignment) {
#ifdef TENSORFLOW_USE_JEMALLOC
void* ptr = NULL;
// posix_memalign requires that the requested alignment be at least
// sizeof(void*). In this case, fall back on malloc which should return
// memory aligned to at least the size of a pointer.
const int required_alignment = sizeof(void*);
if (minimum_alignment < required_alignment) return Malloc(size);
int err = jemalloc_posix_memalign(&ptr, minimum_alignment, size);
if (err != 0) {
return NULL;
} else {
return ptr;
}
#else
return _aligned_malloc(size, minimum_alignment);
#endif
}
void AlignedFree(void* aligned_memory) {
#ifdef TENSORFLOW_USE_JEMALLOC
jemalloc_free(aligned_memory);
#else
_aligned_free(aligned_memory);
#endif
}
void* Malloc(size_t size) {
#ifdef TENSORFLOW_USE_JEMALLOC
return jemalloc_malloc(size);
#else
return malloc(size);
#endif
}
void* Realloc(void* ptr, size_t size) {
#ifdef TENSORFLOW_USE_JEMALLOC
return jemalloc_realloc(ptr, size);
#else
return realloc(ptr, size);
#endif
}
void Free(void* ptr) {
#ifdef TENSORFLOW_USE_JEMALLOC
return jemalloc_free(ptr);
#else
return free(ptr);
#endif
}
void MallocExtension_ReleaseToSystem(std::size_t num_bytes) {
// No-op.
}
std::size_t MallocExtension_GetAllocatedSize(const void* p) { return 0; }
void AdjustFilenameForLogging(string* filename) {
// Nothing to do
}
bool Snappy_Compress(const char* input, size_t length, string* output) {
#ifdef SNAPPY
output->resize(snappy::MaxCompressedLength(length));
size_t outlen;
snappy::RawCompress(input, length, &(*output)[0], &outlen);
output->resize(outlen);
return true;
#else
return false;
#endif
}
bool Snappy_GetUncompressedLength(const char* input, size_t length,
size_t* result) {
#ifdef SNAPPY
return snappy::GetUncompressedLength(input, length, result);
#else
return false;
#endif
}
bool Snappy_Uncompress(const char* input, size_t length, char* output) {
#ifdef SNAPPY
return snappy::RawUncompress(input, length, output);
#else
return false;
#endif
}
string Demangle(const char* mangled) { return mangled; }
double NominalCPUFrequency() {
// TODO(yuefengz): implement it for this platform.
return 1.0;
}
} // namespace port
} // namespace tensorflow
|
