tests: tmp debug

Author: chenzhuofu

lib/kernels/src/test_utils.cc

@@ -30,8 +30,9 @@ struct CreateRandomFilledAccessorW {
     using T = real_type_t<DT>;
     T *data_ptr = src_accessor.get<DT>();
 
-    std::random_device rd;
-    std::mt19937 gen(rd());
+    // std::random_device rd;
+    // std::mt19937 gen(rd());
+    std::mt19937 gen(42);
     size_t num_elements = get_num_elements(shape).int_from_positive_int();
     if constexpr (std::is_same<T, bool>::value) {
       std::bernoulli_distribution dist(0.5);

lib/local-execution/src/local_training_backing.cc

@@ -12,6 +12,7 @@
 #include "utils/containers/get_only.h"
 #include "utils/containers/values.h"
 #include "utils/exception.h"
+#include "kernels/format_accessor_contents.h"
 
 namespace FlexFlow {
 
@@ -143,8 +144,25 @@ std::optional<float>
                               local_training_backing.local_args_backing,
                               invocation,
                               allocator);
-    return call_task_impl(
+    std::optional<float> result = call_task_impl(
         local_training_backing.task_registry, invocation.task_id, accessor);
+    std::cout << "====== forward ======" << std::endl;
+    std::cout << "weights" << std::endl;
+    std::vector<tensor_guid_t> weights = get_incoming_weights(local_training_backing.computation_graph, operator_node);
+    for (tensor_guid_t tensor : weights) {
+      std::cout << format_accessor_w_contents(local_training_backing.local_tensor_backing.tensor_backings.at(TensorTypeVariant{tensor})) << std::endl;
+    }
+    std::cout << "inputs" << std::endl;
+    std::vector<tensor_guid_t> inputs = get_incoming_inputs(local_training_backing.computation_graph, operator_node);
+    for (tensor_guid_t tensor : inputs) {
+      std::cout << format_accessor_w_contents(local_training_backing.local_tensor_backing.tensor_backings.at(TensorTypeVariant{tensor})) << std::endl;
+    }
+    std::cout << "output" << std::endl;
+    std::vector<tensor_guid_t> outgoing_tensors = get_outgoing_tensors(local_training_backing.computation_graph, operator_node);
+    for (tensor_guid_t tensor : outgoing_tensors) {
+      std::cout << format_accessor_w_contents(local_training_backing.local_tensor_backing.tensor_backings.at(TensorTypeVariant{tensor})) << std::endl;
+    }
+    return result;
   } else {
     return std::nullopt;
   }

lib/local-execution/test/src/test_e2e.cc

@@ -38,8 +38,8 @@ TEST_SUITE(FF_CUDA_TEST_SUITE) {
     loss_tensor_t label_tensor = loss_tensor_source.new_loss_tensor();
 
     positive_int batch_size = 10_p;
-    positive_int data_dim = 16_p;
-    positive_int hidden_dim = 32_p;
+    positive_int data_dim = 4_p;
+    positive_int hidden_dim = 1_p;
     positive_int output_dim = 1_p;
 
     TensorShape input_tensor_shape = TensorShape{
@@ -160,7 +160,7 @@ TEST_SUITE(FF_CUDA_TEST_SUITE) {
 
     Allocator cpu_allocator = create_local_cpu_memory_allocator();
 
-    int num_epochs = 5;
+    int num_epochs = 1;
     std::vector<GenericTensorAccessorR> loss_values;
 
     for (int i = 0; i < num_epochs; i++) {
@@ -173,9 +173,12 @@ TEST_SUITE(FF_CUDA_TEST_SUITE) {
 
     // Assert that each sample in the batch has a lower loss in last epoch than
     // the first epoch
+    // std::cout << "Final loss values" << std::endl;
     GenericTensorAccessorR first_epoch_loss = loss_values.at(0);
+    // std::cout << format_accessor_r_contents(first_epoch_loss) << std::endl;
 
     GenericTensorAccessorR last_epoch = loss_values.back();
+    // std::cout << format_accessor_r_contents(last_epoch) << std::endl;
 
     CHECK(did_loss_decrease(first_epoch_loss, last_epoch));
   }