fix syntax error

test new sample

optimize thrust alloc (PaddlePaddle#112)

fix deepwalk sample kernel (PaddlePaddle#122)

Update graphsage speed(thrust -> cub), fix sample async bug (PaddlePaddle#120)

* fix deepwalk sample kernel, fix inplace kernel sync bug

* update v2 sample

* change kernel name for readability

* delete unused kernel

support slot_feature with different length (PaddlePaddle#124)

Co-authored-by: root <root@yq01-inf-hic-k8s-a100-ab2-0009.yq01.baidu.com>

add graphsage slot feature (PaddlePaddle#126)

【graphsage】don't alloc a new d_feature_buf if the old one is enough (PaddlePaddle#128)

* add graphsage slot feature

* update graphsage slot feature

* update graphsage slot feature

fix linking

use type optimization

remove file

add type-optimization config

fix bug in slot_feature (PaddlePaddle#134)

Co-authored-by: root <root@yq01-inf-hic-k8s-a100-ab2-0009.yq01.baidu.com>

sage network optimization

remove log

fix bug in slot_feature (PaddlePaddle#134)

Co-authored-by: root <root@yq01-inf-hic-k8s-a100-ab2-0009.yq01.baidu.com>

Author: seemingwang

paddle/fluid/distributed/ps/table/common_graph_table.cc

@@ -72,6 +72,11 @@ paddle::framework::GpuPsCommGraphFea GraphTable::make_gpu_ps_graph_fea(
   std::vector<uint64_t> node_id_array[task_pool_size_];
   std::vector<paddle::framework::GpuPsFeaInfo>
       node_fea_info_array[task_pool_size_];
+  slot_feature_num_map_.resize(slot_num);
+  for (int k = 0; k < slot_num; ++k) {
+    slot_feature_num_map_[k] = 0;
+  }
+
   for (size_t i = 0; i < bags.size(); i++) {
     if (bags[i].size() > 0) {
       tasks.push_back(_shards_task_pool[i]->enqueue([&, i, this]() -> int {
@@ -92,13 +97,17 @@ paddle::framework::GpuPsCommGraphFea GraphTable::make_gpu_ps_graph_fea(
             int total_feature_size = 0;
             for (int k = 0; k < slot_num; ++k) {
               v->get_feature_ids(k, &feature_ids);
-              total_feature_size += feature_ids.size();
+              int feature_ids_size = feature_ids.size();
+              if (slot_feature_num_map_[k] < feature_ids_size) {
+                slot_feature_num_map_[k] = feature_ids_size;
+              }
+              total_feature_size += feature_ids_size;
               if (!feature_ids.empty()) {
                 feature_array[i].insert(feature_array[i].end(),
                                         feature_ids.begin(),
                                         feature_ids.end());
                 slot_id_array[i].insert(
-                    slot_id_array[i].end(), feature_ids.size(), k);
+                    slot_id_array[i].end(), feature_ids_size, k);
               }
             }
             x.feature_size = total_feature_size;
@@ -111,6 +120,13 @@ paddle::framework::GpuPsCommGraphFea GraphTable::make_gpu_ps_graph_fea(
     }
   }
   for (int i = 0; i < (int)tasks.size(); i++) tasks[i].get();
+
+  std::stringstream ss;
+  for (int k = 0; k < slot_num; ++k) {
+    ss << slot_feature_num_map_[k] << " ";
+  }
+  VLOG(0) << "slot_feature_num_map: " << ss.str();
+
   paddle::framework::GpuPsCommGraphFea res;
   uint64_t tot_len = 0;
   for (int i = 0; i < task_pool_size_; i++) {
@@ -1849,9 +1865,14 @@ int GraphTable::parse_feature(int idx,
   // "")
   thread_local std::vector<paddle::string::str_ptr> fields;
   fields.clear();
-  const char c = feature_separator_.at(0);
+  char c = slot_feature_separator_.at(0);
   paddle::string::split_string_ptr(feat_str, len, c, &fields);
 
+  thread_local std::vector<paddle::string::str_ptr> fea_fields;
+  fea_fields.clear();
+  c = feature_separator_.at(0);
+  paddle::string::split_string_ptr(fields[1].ptr, fields[1].len, c, &fea_fields);
+
   std::string name = fields[0].to_string();
   auto it = feat_id_map[idx].find(name);
   if (it != feat_id_map[idx].end()) {
@@ -1862,26 +1883,26 @@ int GraphTable::parse_feature(int idx,
       //      string_vector_2_string(fields.begin() + 1, fields.end(), ' ',
       //      fea_ptr);
       FeatureNode::parse_value_to_bytes<uint64_t>(
-          fields.begin() + 1, fields.end(), fea_ptr);
+          fea_fields.begin(), fea_fields.end(), fea_ptr);
       return 0;
     } else if (dtype == "string") {
-      string_vector_2_string(fields.begin() + 1, fields.end(), ' ', fea_ptr);
+      string_vector_2_string(fea_fields.begin(), fea_fields.end(), ' ', fea_ptr);
       return 0;
     } else if (dtype == "float32") {
       FeatureNode::parse_value_to_bytes<float>(
-          fields.begin() + 1, fields.end(), fea_ptr);
+          fea_fields.begin(), fea_fields.end(), fea_ptr);
       return 0;
     } else if (dtype == "float64") {
       FeatureNode::parse_value_to_bytes<double>(
-          fields.begin() + 1, fields.end(), fea_ptr);
+          fea_fields.begin(), fea_fields.end(), fea_ptr);
       return 0;
     } else if (dtype == "int32") {
       FeatureNode::parse_value_to_bytes<int32_t>(
-          fields.begin() + 1, fields.end(), fea_ptr);
+          fea_fields.begin(), fea_fields.end(), fea_ptr);
       return 0;
     } else if (dtype == "int64") {
       FeatureNode::parse_value_to_bytes<uint64_t>(
-          fields.begin() + 1, fields.end(), fea_ptr);
+          fea_fields.begin(), fea_fields.end(), fea_ptr);
       return 0;
     }
   } else {
@@ -2118,6 +2139,10 @@ void GraphTable::set_feature_separator(const std::string &ch) {
   feature_separator_ = ch;
 }
 
+void GraphTable::set_slot_feature_separator(const std::string &ch) {
+  slot_feature_separator_ = ch;
+}
+
 int32_t GraphTable::get_server_index_by_id(uint64_t id) {
   return id % shard_num / shard_num_per_server;
 }

paddle/fluid/distributed/ps/table/common_graph_table.h

@@ -681,6 +681,7 @@ class GraphTable : public Table {
   int32_t make_complementary_graph(int idx, int64_t byte_size);
   int32_t dump_edges_to_ssd(int idx);
   int32_t get_partition_num(int idx) { return partitions[idx].size(); }
+  std::vector<int> slot_feature_num_map() const { return slot_feature_num_map_; }
   std::vector<uint64_t> get_partition(int idx, int index) {
     if (idx >= (int)partitions.size() || index >= (int)partitions[idx].size())
       return std::vector<uint64_t>();
@@ -698,6 +699,7 @@ class GraphTable : public Table {
 #endif
   virtual int32_t add_comm_edge(int idx, uint64_t src_id, uint64_t dst_id);
   virtual int32_t build_sampler(int idx, std::string sample_type = "random");
+  void set_slot_feature_separator(const std::string &ch);
   void set_feature_separator(const std::string &ch);
   std::vector<std::vector<GraphShard *>> edge_shards, feature_shards;
   size_t shard_start, shard_end, server_num, shard_num_per_server, shard_num;
@@ -728,7 +730,7 @@ class GraphTable : public Table {
   mutable std::mutex mutex_;
   bool build_sampler_on_cpu;
   bool is_load_reverse_edge = false;
-  std::vetor<std::vector<int>> node_id_to_edge_types, edge_type_outputs;
+  std::vector<std::vector<int>> node_id_to_edge_types, edge_type_outputs;
   std::shared_ptr<pthread_rwlock_t> rw_lock;
 #ifdef PADDLE_WITH_HETERPS
   // paddle::framework::GpuPsGraphTable gpu_graph_table;
@@ -737,7 +739,9 @@ class GraphTable : public Table {
   // std::shared_ptr<GraphSampler> graph_sampler;
   // REGISTER_GRAPH_FRIEND_CLASS(2, CompleteGraphSampler, BasicBfsGraphSampler)
 #endif
+  std::string slot_feature_separator_ = std::string(" ");
   std::string feature_separator_ = std::string(" ");
+  std::vector<int> slot_feature_num_map_;
 };
 
 /*