dp_vs调度（一）：dp_vs_scheduler

• dp_vs_scheduler

  struct dp_vs_scheduler {
  		//用于将已注册的scheduler都挂接在全局dp_vs_schedulers链表中
      struct list_head    n_list;
  		//调度算法名称
      char                *name;
  //    rte_atomic32_t      refcnt;
  		//以下为虚函数表
      struct dp_vs_dest *
          (*schedule)(struct dp_vs_service *svc,
                      const struct rte_mbuf *mbuf);
  
      int (*init_service)(struct dp_vs_service *svc);
      int (*exit_service)(struct dp_vs_service *svc);
      int (*update_service)(struct dp_vs_service *svc, struct dp_vs_dest *dest,
              sockoptid_t opt);
  } __rte_cache_aligned;
  

• dp_vs_sched_init

  • 初始化不同的scheduler算法，包括rr，wrr，wlc，conhash，fo

  /*
   *  IPVS scheduler list
   * 保存所有已注册scheduler的全局双向链表
   */
  static struct list_head dp_vs_schedulers;
  
  /* lock for service table */
  static rte_rwlock_t __dp_vs_sched_lock;
  int dp_vs_sched_init(void)
  {
      INIT_LIST_HEAD(&dp_vs_schedulers);
      rte_rwlock_init(&__dp_vs_sched_lock);
      dp_vs_rr_init();
      dp_vs_wrr_init();
      dp_vs_wlc_init();
      dp_vs_conhash_init();
      dp_vs_fo_init();
  
      return EDPVS_OK;
  }
  

• 注册

  /*
   *  Register a scheduler in the scheduler list
   */
  int register_dp_vs_scheduler(struct dp_vs_scheduler *scheduler)
  {
      struct dp_vs_scheduler *sched;
  
      if (!scheduler) {
          return EDPVS_INVAL;
      }
  
      if (!scheduler->name) {
          return EDPVS_INVAL;
      }
  
      rte_rwlock_write_lock(&__dp_vs_sched_lock);
  
      if (!list_empty(&scheduler->n_list)) {
          rte_rwlock_write_unlock(&__dp_vs_sched_lock);
          return EDPVS_EXIST;
      }
  
      /*
       *  Make sure that the scheduler with this name doesn't exist
       *  in the scheduler list.
       */
      list_for_each_entry(sched, &dp_vs_schedulers, n_list) {
          if (strcmp(scheduler->name, sched->name) == 0) {
              rte_rwlock_write_unlock(&__dp_vs_sched_lock);
              return EDPVS_EXIST;
          }
      }
      /*
       *      Add it into the d-linked scheduler list
       */
      list_add(&scheduler->n_list, &dp_vs_schedulers);
      rte_rwlock_write_unlock(&__dp_vs_sched_lock);
  
      return EDPVS_OK;
  }
  

• 注销

  /*
   *  Unregister a scheduler from the scheduler list
   */
  int unregister_dp_vs_scheduler(struct dp_vs_scheduler *scheduler)
  {
      if (!scheduler) {
          return EDPVS_INVAL;
      }
  
      rte_rwlock_write_lock(&__dp_vs_sched_lock);
      if (list_empty(&scheduler->n_list)) {
          rte_rwlock_write_unlock(&__dp_vs_sched_lock);
          return EDPVS_NOTEXIST;
      }
  
      /*
       *      Remove it from the d-linked scheduler list
       */
      list_del(&scheduler->n_list);
      rte_rwlock_write_unlock(&__dp_vs_sched_lock);
  
      return EDPVS_OK;
  }
  

• service与scheduler绑定

  /*
   *  Bind a service with a scheduler
   */
  int dp_vs_bind_scheduler(struct dp_vs_service *svc,
                           struct dp_vs_scheduler *scheduler)
  {
      int ret;
  
      if (svc == NULL) {
          return EDPVS_INVAL;
      }
      if (scheduler == NULL) {
          return EDPVS_INVAL;
      }
  
      svc->scheduler = scheduler;
  
      if (scheduler->init_service) {
          ret = scheduler->init_service(svc);
          if (ret) {
              return ret;
          }
      }
  
      return EDPVS_OK;
  }
  

• service与scheduler解绑

  /*
   *  Unbind a service with its scheduler
   */
  int dp_vs_unbind_scheduler(struct dp_vs_service *svc)
  {
      struct dp_vs_scheduler *sched;
  
      if (svc == NULL) {
          return EDPVS_INVAL;;
      }
  
      sched = svc->scheduler;
      if (sched == NULL) {
          return EDPVS_INVAL;
      }
  
      if (sched->exit_service) {
          if (sched->exit_service(svc) != 0) {
              return EDPVS_INVAL;
          }
      }
  
      svc->scheduler = NULL;
      return EDPVS_OK;
  }