| /external/tensorflow/tensorflow/core/kernels/ |
| unpack_op.cc | 39 template <typename Device, typename T>
118 functor::Split<Device, T>()(context->eigen_device<Device>(),
131 Name("Unpack").Device(DEVICE_CPU).TypeConstraint<type>("T"), \
142 Name("Unpack").Device(DEVICE_GPU).TypeConstraint<type>("T"), \
150 // TODO(b/25387198): Also enable int32 in device memory. This kernel
153 .Device(DEVICE_GPU)
159 .Device(DEVICE_GPU)
170 Name("Unpack").Device(DEVICE_SYCL).TypeConstraint<type>("T"), \
176 .Device(DEVICE_SYCL
[all...] |
| concat_op.cc | 45 template <typename Device, typename T, AxisArgumentName AxisArgName>
136 if (std::is_same<Device, GPUDevice>::value) {
142 if (std::is_same<Device, SYCLDevice>::value) {
147 ConcatCPU<T>(c->device(), inputs_flat, &output_flat);
152 template <typename Device, typename T>
153 using ConcatOp = ConcatBaseOp<Device, T, NAME_IS_CONCAT_DIM>;
154 template <typename Device, typename T>
155 using ConcatV2Op = ConcatBaseOp<Device, T, NAME_IS_AXIS>;
159 .Device(DEVICE_CPU) \
164 .Device(DEVICE_CPU)
[all...] |
| function_ops.cc | 19 #include "tensorflow/core/common_runtime/device.h"
92 REGISTER_SYSTEM_KERNEL_BUILDER(Name("_Arg").Device(DEVICE_CPU), ArgOp);
93 REGISTER_SYSTEM_KERNEL_BUILDER(Name("_Retval").Device(DEVICE_CPU), RetvalOp);
98 Name("_Arg").Device(DEVICE_SYCL).TypeConstraint<type>("T"), ArgOp);
101 .Device(DEVICE_SYCL)
108 Name("_Retval").Device(DEVICE_SYCL).TypeConstraint<type>("T"), \
112 .Device(DEVICE_SYCL)
121 Name("_Arg").Device(DEVICE_GPU).TypeConstraint<type>("T"), ArgOp);
124 .Device(DEVICE_GPU)
131 .Device(DEVICE_GPU
[all...] |
| quantize_and_dequantize_op.cc | 41 template <typename Device, typename T>
77 functor::QuantizeAndDequantizeOneScaleFunctor<Device, T> f;
78 f(ctx->eigen_device<Device>(), input.flat<T>(), signed_input_, num_bits_,
95 template <typename Device, typename T>
136 functor::QuantizeAndDequantizeOneScaleFunctor<Device, T> f;
137 f(ctx->eigen_device<Device>(), input.flat<T>(), signed_input_, num_bits_val,
147 template <typename Device, typename T>
180 functor::QuantizeAndDequantizeOneScaleFunctor<Device, T> functor;
181 functor(ctx->eigen_device<Device>(), input.flat<T>(), signed_input_,
211 .Device(DEVICE_CPU)
[all...] |
| variable_ops.cc | 180 REGISTER_KERNEL_BUILDER(Name("Variable").Device(DEVICE_CPU), VariableOp);
181 REGISTER_KERNEL_BUILDER(Name("VariableV2").Device(DEVICE_CPU), VariableOp);
182 REGISTER_KERNEL_BUILDER(Name("TemporaryVariable").Device(DEVICE_CPU),
184 REGISTER_KERNEL_BUILDER(Name("DestroyTemporaryVariable").Device(DEVICE_CPU),
186 REGISTER_KERNEL_BUILDER(Name("IsVariableInitialized").Device(DEVICE_CPU),
192 Name("Variable").Device(DEVICE_SYCL).TypeConstraint<type>("dtype"), \
195 Name("VariableV2").Device(DEVICE_SYCL).TypeConstraint<type>("dtype"), \
198 .Device(DEVICE_SYCL) \
202 .Device(DEVICE_SYCL) \
206 .Device(DEVICE_SYCL)
[all...] |
| stateless_random_ops.cc | 87 // The part of Compute that depends on device, type, and distribution
92 template <typename Device, class Distribution>
102 functor::FillPhiloxRandom<Device, Distribution>()(
103 context, context->eigen_device<Device>(), random, flat.data(),
113 .Device(DEVICE_CPU) \
120 .Device(DEVICE_CPU) \
127 .Device(DEVICE_CPU) \
146 .Device(DEVICE_GPU) \
154 .Device(DEVICE_GPU) \
162 .Device(DEVICE_GPU)
[all...] |
| matrix_diag_op.cc | 43 template <typename Device, typename T>
75 functor::MatrixDiagPart<Device, T>::Compute(
76 context->eigen_device<Device>(), input_reshaped, output_reshaped);
83 template <typename Device, typename T>
111 functor::MatrixDiag<Device, T>::Compute(context->eigen_device<Device>(),
121 Name("MatrixDiag").Device(DEVICE_CPU).TypeConstraint<type>("T"), \
124 Name("MatrixDiagPart").Device(DEVICE_CPU).TypeConstraint<type>("T"), \
133 Name("BatchMatrixDiag").Device(DEVICE_CPU).TypeConstraint<type>("T"), \
136 .Device(DEVICE_CPU)
[all...] |
| reader_ops.cc | 99 REGISTER_KERNEL_BUILDER(Name("ReaderRead").Device(DEVICE_CPU), ReaderReadOp);
100 REGISTER_KERNEL_BUILDER(Name("ReaderReadV2").Device(DEVICE_CPU), ReaderReadOp);
151 REGISTER_KERNEL_BUILDER(Name("ReaderReadUpTo").Device(DEVICE_CPU),
153 REGISTER_KERNEL_BUILDER(Name("ReaderReadUpToV2").Device(DEVICE_CPU),
169 REGISTER_KERNEL_BUILDER(Name("ReaderNumRecordsProduced").Device(DEVICE_CPU),
171 REGISTER_KERNEL_BUILDER(Name("ReaderNumRecordsProducedV2").Device(DEVICE_CPU),
187 REGISTER_KERNEL_BUILDER(Name("ReaderNumWorkUnitsCompleted").Device(DEVICE_CPU),
190 Name("ReaderNumWorkUnitsCompletedV2").Device(DEVICE_CPU),
207 REGISTER_KERNEL_BUILDER(Name("ReaderSerializeState").Device(DEVICE_CPU),
209 REGISTER_KERNEL_BUILDER(Name("ReaderSerializeStateV2").Device(DEVICE_CPU)
[all...] |
| stack_ops.cc | 22 #include "tensorflow/core/common_runtime/device.h"
228 REGISTER_KERNEL_BUILDER(Name("Stack").Device(DEVICE_CPU), StackOp);
229 REGISTER_KERNEL_BUILDER(Name("Stack").Device(DEVICE_GPU).HostMemory("handle"),
231 REGISTER_KERNEL_BUILDER(Name("StackV2").Device(DEVICE_CPU), StackOp);
233 .Device(DEVICE_GPU)
238 REGISTER_KERNEL_BUILDER(Name("Stack").Device(DEVICE_SYCL).HostMemory("handle"),
241 .Device(DEVICE_SYCL)
247 template <typename Device>
277 (std::is_same<Device, GPUDevice>::value
279 || std::is_same<Device, SYCLDevice>::valu
284 auto device = static_cast<tensorflow::Device*>(ctx->device()); variable
413 Device* device = static_cast<Device*>(ctx->device()); variable
[all...] |
| /device/linaro/bootloader/OpenPlatformPkg/Chips/Hisilicon/Hi1616/D05AcpiTables/Dsdt/ |
| D05Mbig.asl | 19 Device(MBI0) {
39 Device(MBI1) {
94 Device(MBI2) {
147 Device(MBI3) { // Mbi-gen sas1 intc
199 Device(MBI4) { // Mbi-gen sas2 intc
252 Device(MBI5) {
272 Device(MBI6) {
292 Device(MBI7) {
312 Device(MBI8) {
378 Device(MBI4) { // Mbi-gen dsa1 dbg0 intc
[all...] |
| /device/linaro/bootloader/edk2/Vlv2DeviceRefCodePkg/AcpiTablesPCAT/ |
| PchEhci.asl | 57 Device(HUBN)
60 Device(PR01)
66 // in Windows "Device Manager" while RMH is enabled, so need to add _UPC
89 Device(PR11)
111 Device(PR12)
133 Device(PR13)
155 Device(PR14)
181 Device(PR15)
205 Device(PR16)
229 Device(PR17)
[all...] |
| /external/tensorflow/tensorflow/contrib/framework/kernels/ |
| zero_initializer_op.cc | 32 template <typename Device, typename T>
53 functor::TensorSetZero<Device, T>()(ctx->eigen_device<Device>(),
63 Name("ZeroInitializer").Device(DEVICE_##D).TypeConstraint<T>("T"), \
64 ZeroInitializerOp<D##Device, T>);
|
| /device/linaro/bootloader/OpenPlatformPkg/Chips/Hisilicon/Hi1610/Hi1610AcpiTables/ |
| D03Iort.asl | 54 Device Attribute : 0
56 [0017] Device Name : "\_SB_.MBI0"
61 [0004] Output Base : 00040080 // device id
85 Device Attribute : 0
87 [0016] Device Name : "\_SB_.MBI1"
116 Device Attribute : 0
118 [0016] Device Name : "\_SB_.MBI2"
147 Device Attribute : 0
149 [0016] Device Name : "\_SB_.MBI3"
178 Device Attribute : 0
[all...] |
| /frameworks/native/services/inputflinger/ |
| EventHub.h | 46 * through evdev from uinput device drivers because there is currently no
61 // Device id of a special "virtual" keyboard that is always present.
63 // Device id of the "built-in" keyboard if there is one.
99 * Input device classes.
102 /* The input device is a keyboard or has buttons. */
105 /* The input device is an alpha-numeric keyboard (not just a dial pad). */
108 /* The input device is a touchscreen or a touchpad (either single-touch or multi-touch). */
111 /* The input device is a cursor device such as a trackball or mouse. */
114 /* The input device is a multi-touch touchscreen. *
[all...] |
| /device/linaro/bootloader/edk2/MdeModulePkg/Bus/Sd/EmmcDxe/ |
| EmmcDxe.c | 2 The EmmcDxe driver is used to manage the EMMC device.
5 access the EMMC device.
80 NULL // Device
101 DEBUG((DEBUG_INFO, " Device command classes 0x%x\n", Csd->Ccc));
107 DEBUG((DEBUG_INFO, " Device size 0x%x\n", Csd->CSizeLow | (Csd->CSizeHigh << 2)));
112 DEBUG((DEBUG_INFO, " Device size multiplier 0x%x\n", Csd->CSizeMult));
167 DEBUG((DEBUG_INFO, " Device type 0x%x\n", ExtCsd->DeviceType));
211 Get EMMC device model name.
213 @param[in, out] Device The pointer to the EMMC_DEVICE data structure.
221 IN OUT EMMC_DEVICE *Device,
[all...] |
| EmmcBlockIo.c | 62 Send command SELECT to the device to select/deselect the device.
64 @param[in] Device A pointer to the EMMC_DEVICE instance.
65 @param[in] Rca The relative device address to use.
74 IN EMMC_DEVICE *Device,
84 PassThru = Device->Private->PassThru;
98 Status = PassThru->PassThru (PassThru, Device->Slot, &Packet, NULL);
104 Send command SEND_STATUS to the device to get device status.
106 @param[in] Device A pointer to the EMMC_DEVICE instance.
[all...] |
| /external/eigen/unsupported/Eigen/CXX11/src/Tensor/ |
| TensorRef.h | 42 template <typename Dimensions, typename Expr, typename Device>
43 class TensorLazyEvaluatorReadOnly : public TensorLazyBaseEvaluator<Dimensions, typename TensorEvaluator<Expr, Device>::Scalar> {
45 // typedef typename TensorEvaluator<Expr, Device>::Dimensions Dimensions;
46 typedef typename TensorEvaluator<Expr, Device>::Scalar Scalar;
48 TensorLazyEvaluatorReadOnly(const Expr& expr, const Device& device) : m_impl(expr, device), m_dummy(Scalar(0)) {
72 TensorEvaluator<Expr, Device> m_impl;
77 template <typename Dimensions, typename Expr, typename Device>
78 class TensorLazyEvaluatorWritable : public TensorLazyEvaluatorReadOnly<Dimensions, Expr, Device> {
[all...] |
| /external/tensorflow/tensorflow/core/distributed_runtime/ |
| session_mgr_test.cc | 25 class FakeDevice : public Device {
28 : Device(nullptr, device_attributes) {}
35 static std::unique_ptr<Device> MakeCPU(const string& name) {
39 return std::unique_ptr<Device>(new FakeDevice(device_attributes));
47 "/job:mnist/replica:0/task:0/device:fakecpu:0")),
54 std::unique_ptr<Device> device_;
85 std::vector<Device*> devices_1 = session_1->device_mgr->ListDevices();
90 std::vector<Device*> devices_2 = session_2->device_mgr->ListDevices();
95 std::vector<Device*> devices_3 = session_3->device_mgr->ListDevices();
100 std::vector<Device*> devices_4 = session_4->device_mgr->ListDevices()
[all...] |
| /system/bt/profile/avrcp/ |
| device.cc | 20 #include "device.h"
32 Device::Device(
45 void Device::RegisterInterfaces(MediaInterface* media_interface,
55 bool Device::IsActive() const {
59 void Device::VendorPacketHandler(uint8_t label,
110 &Device::GetElementAttributesResponse, weak_ptr_factory_.GetWeakPtr(),
115 media_interface_->GetPlayStatus(base::Bind(&Device::GetPlayStatusResponse,
143 void Device::HandleGetCapabilities(
183 void Device::HandleNotification
[all...] |
| /device/linaro/bootloader/edk2/OvmfPkg/Library/VirtioMmioDeviceLib/ |
| VirtioMmioDevice.h | 3 Internal definitions for the VirtIo MMIO Device driver
37 #define VIRTIO_MMIO_DEVICE_FROM_VIRTIO_DEVICE(Device) \
38 CR (Device, VIRTIO_MMIO_DEVICE, VirtioDevice, VIRTIO_MMIO_DEVICE_SIGNATURE)
40 #define VIRTIO_CFG_WRITE(Device, Offset, Val) \
41 (MmioWrite32 (Device->BaseAddress + (Offset), Val))
42 #define VIRTIO_CFG_READ(Device, Offset) \
43 (MmioRead32 (Device->BaseAddress + (Offset)))
|
| /device/linaro/bootloader/edk2/QuarkPlatformPkg/Acpi/AcpiTables/Dsdt/ |
| PCAL9555A.asi | 16 Device(NIO1)
33 // Only Platform Type / Id 8 has this device.
43 Device(NIO2)
60 // Only Platform Type / Id 8 has this device.
70 Device(NIO3)
88 // Only Platform Type / Id 8 has this device.
|
| /external/tensorflow/tensorflow/c/eager/ |
| c_api_internal.h | 71 // One FunctionLibraryRuntime per device.
81 tensorflow::FunctionLibraryRuntime* func_lib(tensorflow::Device* d) const {
85 const std::vector<tensorflow::Device*>& devices() { return session->devices; }
94 TFE_TensorHandle(const tensorflow::Tensor& t, tensorflow::Device* d)
106 tensorflow::Device* d;
113 : ctx(ctx), name(op), attrs(op), attr_types(t), device(nullptr) {}
122 std::vector<tensorflow::Device*> input_devices;
123 tensorflow::Device* device; member in struct:TFE_Op
|
| /external/tensorflow/tensorflow/contrib/image/kernels/ |
| image_ops.cc | 51 template <typename Device, typename T>
80 ProjectiveGenerator<Device, T>::kNumParameters),
88 (FillProjectiveTransform<Device, T>(interpolation_))(
89 ctx->eigen_device<Device>(), &output, images, transform);
95 .Device(DEVICE_CPU) \
118 const GPUDevice& device, OutputType* output, const InputType& images, \
132 .Device(DEVICE_GPU) \
|
| /external/tensorflow/tensorflow/core/common_runtime/ |
| renamed_device.h | 19 #include "tensorflow/core/common_runtime/device.h"
24 // Wraps a device with a new name, delegating work to the wrapped device.
27 // where the name of a particular device may change in the context of a given
29 class RenamedDevice : public Device {
31 static Device* NewRenamedDevice(const string& new_base, Device* underlying,
80 void ReinitializeGpuDevice(OpKernelContext* context, PerOpGpuDevice* device,
82 underlying_->ReinitializeGpuDevice(context, device, dc, allocator);
91 // Below are virtual methods defined on Device
[all...] |
| /external/tensorflow/tensorflow/python/client/ |
| device_lib.i | 19 #include "tensorflow/core/common_runtime/device.h"
31 std::vector<Device*> devices;
38 std::vector<std::unique_ptr<Device>> device_holder(devices.begin(), devices.end());
40 for (const Device* device : devices) {
41 const DeviceAttributes& attr = device->attributes();
46 errors::Internal("Could not serialize device string"));
|
