bucketing_manager.h
#ifndef BUCKETING_MANAGER_H
#define BUCKETING_MANAGER_H
#include "rmsummary.h"
#include "hash_table.h"
#include "bucketing_greedy.h"
#include "bucketing_exhaust.h"
/* A bucketing manager has its bucketing mode, a table mapping resource
* type to its bucketing state, and a table mapping task id to its latest
* resource summary */
typedef struct
{
bucketing_mode_t mode; //bucketing mode
struct hash_table* res_type_to_bucketing_state; //mapping of resource type to bucketing state
struct hash_table* task_id_to_task_rmsummary; //mapping of task id to its previous resource summary from either actual run or prediction
}
bucketing_manager_t;
/* Create a bucketing manager
* @param mode bucketing mode of manager
* @return pointer to a newly created bucketing manager */
bucketing_manager_t* bucketing_manager_create(bucketing_mode_t mode);
/* Create and initialize a bucketing manager
* @param mode algorithm to do bucketing
* @return pointer to a created and initialized bucketing manager */
bucketing_manager_t* bucketing_manager_initialize(bucketing_mode_t mode);
/* Delete a bucketing manager
* @param m the manager to be deleted */
void bucketing_manager_delete(bucketing_manager_t* m);
/* Add a new type of resource to the manager
* Do nothing if this resource is already in manager
* @param m the relevant manager
* @param r the string of the resource (e.g., "cores")
* @param set_default set default values for resource, only support cores, memory, and disk and ignore the rest of the arguments
* see this function's definition for more info
* @param default_value the first base value to allocate new tasks (e.g.,"mem": 1000 means try 1GBs of mem to new tasks)
* @param num_sampling_points number of sampling points
* @param increase_rate the rate to increase value when task fails in sampling phase or when task consumes more than any other tasks in predicting phase
* @param max_num_buckets the maximum number of buckets to try to break (only for EXHAUSTIVE_BUCKETING)
* @param update_epoch the number of iterations before rebucketing */
void bucketing_manager_add_resource_type(bucketing_manager_t* m, const char* r,
int set_default, double default_value, int num_sampling_points,
double increase_rate, int max_num_buckets, int update_epoch);
/* Remove a type of resource from the manager
* Do nothing if this resource is not in manager
* @param m the relevant manager
* @param r the string of the resource (e.g., "cores") */
void bucketing_manager_remove_resource_type(bucketing_manager_t* m, const char* r);
/* Set the bucketing algorithm of a manager
* @param m the relevant manager
* @param mode the mode of algorithm to change to */
void bucketing_manager_set_mode(bucketing_manager_t* m, bucketing_mode_t mode);
/* Tune the bucketing state by resource
* @param m the bucketing manager
* @param res_name the name of resource to tune its bucketing state
* @param field the field in bucketing state to tune
* @param val the value of field */
void bucketing_manager_tune_by_resource(bucketing_manager_t* m, const char* res_name,
const char* field, void* val);
/* Given a task id, the manager returns a predicted allocation and adds this prediction into internal state. The caller is responsible for free'ing the returned value.
* @param m the relevant manager
* @param task_id the task id
* @return a pointer to a newly created rmsummary containing the prediction
* this rmsummary's entries are 0 if no prediction, otherwise entries are predicted
* @return 0 if failure */
struct rmsummary* bucketing_manager_predict(bucketing_manager_t* m, int task_id);
/* Add a task's resource summary to the manager. The caller is responsible for free'ing the parameter r after calling this function. This function should only be called when task succeeds or fails due to resource exhaustion
* @param m the relevant manager
* @param task_id task id of task to be added
* @param r the resource summary of a task
* @param success whether task succeeds in running or not (i.e., task doesn't exceed resource limits) (1 is yes 0 is no) */
void bucketing_manager_add_resource_report(bucketing_manager_t* m, int task_id, struct rmsummary* r, int success);
#endif
hash_table.h
A general purpose hash table.
bucketing_manager_t
Definition bucketing_manager.h:13
rmsummary
Definition rmsummary.h:27