Search Options

Results per page
Sort
Preferred Languages
Advance

Results 11 - 19 of 19 for We (0.13 sec)

  1. tensorflow/c/eager/parallel_device/parallel_device_test.cc

    }
    
    TEST(PARALLEL_DEVICE, TestCollectiveSync) { TestCollective(/*async=*/false); }
    
    // Note that ops on the parallel device currently don't execute
    // asynchronously. The test is just that we don't get deadlocks.
    TEST(PARALLEL_DEVICE, TestCollectiveAsync) { TestCollective(/*async=*/true); }
    
    void RegisterCollectiveMulFunction(TFE_Context* context,
    C++
    - Registered: Tue Apr 30 12:39:09 GMT 2024
    - Last Modified: Thu Jul 08 23:47:35 GMT 2021
    - 29.3K bytes
    - Viewed (1)
  2. tensorflow/c/experimental/filesystem/modular_filesystem_registration.cc

      return OkStatus();
    }
    
    // Validates the random access file operations supplied by the plugin.
    static Status ValidateHelper(const TF_RandomAccessFileOps* ops) {
      if (ops == nullptr) {
        // We allow filesystems where files can only be written to (from TF code)
        return OkStatus();
      }
    
      if (ops->cleanup == nullptr)
        return errors::FailedPrecondition(
    C++
    - Registered: Tue Apr 30 12:39:09 GMT 2024
    - Last Modified: Tue Mar 07 22:08:43 GMT 2023
    - 12.8K bytes
    - Viewed (0)
  3. tensorflow/c/experimental/filesystem/plugins/gcs/gcs_filesystem.cc

      int64_t read;
      auto content_length = stream.headers().find("content-length");
      if (content_length == stream.headers().end()) {
        // When we read a file with offset that is bigger than the actual file size.
        // GCS will return an empty header (e.g no `content-length` header). In this
        // case, we will set read to `0` and continue.
        read = 0;
      } else if (!absl::SimpleAtoi(content_length->second, &read)) {
    C++
    - Registered: Tue Apr 30 12:39:09 GMT 2024
    - Last Modified: Wed Aug 23 06:55:53 GMT 2023
    - 46.9K bytes
    - Viewed (0)
  4. tensorflow/c/eager/c_api_unified_experimental_graph.cc

        }
        if (op_type_.empty()) {
          return errors::FailedPrecondition(
              "GraphOperation::Reset must be called before calling SetOpName.");
        }
        // TODO(b/145674566): We use Graph::NewName to get a unique name here but
        // this may not be consistent with python's naming policy.
        mutex_lock l(g_->mu);
        op_.reset(new TF_OperationDescription(g_, op_type_.c_str(),
    C++
    - Registered: Tue Apr 30 12:39:09 GMT 2024
    - Last Modified: Tue Mar 12 20:00:09 GMT 2024
    - 15.4K bytes
    - Viewed (1)
  5. tensorflow/c/eager/c_api_experimental.cc

            tensorflow::unwrap(handles[i]);
        if (tensorflow::CustomDeviceTensorHandle::classof(unwrapped_handle)) {
          // One of the inputs we're trying to pack is on a custom device. We'll let
          // the first custom device we see handle all of the packing.
          auto* custom_device_handle =
              tensorflow::down_cast<tensorflow::CustomDeviceTensorHandle*>(
                  unwrapped_handle);
    C++
    - Registered: Tue Apr 30 12:39:09 GMT 2024
    - Last Modified: Thu Apr 11 23:52:39 GMT 2024
    - 35.9K bytes
    - Viewed (3)
  6. tensorflow/c/eager/c_api_unified_experimental_test.cc

        TF_DeleteOutputList(func_outputs);
      }
    
      /**
       * We traced so far this function:
       *
       *   def two_adds(a, b):
       *     my_add1 = a + b
       *     my_add2 = b + b
       *     return my_add1, my_add2
       *
       * Now we will execute this function with an eager context:
       *
       *   output1, output2 = two_adds(2.0, 3.0)
       *
       * and check that we got 5.0 and 6.0 as results.
       */
    
      // Build eager context.
    C++
    - Registered: Tue Apr 30 12:39:09 GMT 2024
    - Last Modified: Fri May 19 21:44:52 GMT 2023
    - 39.1K bytes
    - Viewed (0)
  7. tensorflow/c/eager/c_api.cc

        return nullptr;
      }
      std::vector<int64_t> dimvec(num_dims);
      for (int i = 0; i < num_dims; ++i) {
        dimvec[i] = static_cast<int64_t>(dims[i]);
      }
    
      // TODO(apassos) do we need to wrap the deallocator here to make sure to sync
      // the device?
      TF_ManagedBuffer* buf =
          new TF_ManagedBuffer(data, len, deallocator, deallocator_arg,
                               /*owns_memory=*/false);
    
    C++
    - Registered: Tue Apr 30 12:39:09 GMT 2024
    - Last Modified: Tue Mar 12 20:00:09 GMT 2024
    - 43.9K bytes
    - Viewed (2)
  8. tensorflow/c/experimental/filesystem/plugins/gcs/ram_file_block_cache_test.cc

      TF_EXPECT_OK(ReadCache(&cache4, want_filename, want_offset, want_n, &out));
      EXPECT_EQ(calls, 4);
    }
    
    TEST(RamFileBlockCacheTest, BlockAlignment) {
      // Initialize a 256-byte buffer.  This is the file underlying the reads we'll
      // do in this test.
      const size_t size = 256;
      std::vector<char> buf;
      buf.reserve(size);
      for (int i = 0; i < size; i++) {
        buf.push_back(i);
      }
    C++
    - Registered: Tue Apr 23 12:39:09 GMT 2024
    - Last Modified: Fri Oct 15 03:16:57 GMT 2021
    - 23.2K bytes
    - Viewed (0)
  9. tensorflow/c/experimental/filesystem/modular_filesystem.cc

      UniquePtrTo_TF_Status plugin_status(TF_NewStatus(), TF_DeleteStatus);
      std::string translated_name = TranslateName(dir);
      // Note that `children` is allocated by the plugin and freed by core
      // TensorFlow, so we need to use `plugin_memory_free_` here.
      char** children = nullptr;
      const int num_children =
          ops_->get_children(filesystem_.get(), translated_name.c_str(), &children,
                             plugin_status.get());
    C++
    - Registered: Tue Apr 30 12:39:09 GMT 2024
    - Last Modified: Wed Sep 06 19:12:29 GMT 2023
    - 23.1K bytes
    - Viewed (0)
Back to top