Add implementation of packed core alloc strategy
[akaros.git] / kern / include / corerequest.h
1 /* Copyright (c) 2009, 2012, 2015 The Regents of the University of California
2  * Barret Rhoden <brho@cs.berkeley.edu>
3  * Valmon Leymarie <leymariv@berkeley.edu>
4  * Kevin Klues <klueska@cs.berkeley.edu>
5  * See LICENSE for details.
6  */
7
8 #pragma once
9
10 #include <stdbool.h>
11 #include <arch/topology.h>
12 #if defined(CONFIG_COREALLOC_FCFS)
13   #include <corealloc_fcfs.h>
14 #elif defined(CONFIG_COREALLOC_PACKED)
15   #include <corealloc_packed.h>
16 #endif
17
18 /* Initialize any data assocaited with doing core allocation. */
19 void corealloc_init(void);
20
21 /* Initialize any data associated with allocating cores to a process. */
22 void corealloc_proc_init(struct proc *p);
23
24 /* Find the best core to allocate to a process as dictated by the core
25  * allocation algorithm. If no core is found, return -1. This code assumes
26  * that the scheduler that uses it holds a lock for the duration of the call.
27  * */
28 uint32_t __find_best_core_to_alloc(struct proc *p);
29
30 /* Track the pcore properly when it is allocated to p. This code assumes that
31  * the scheduler that uses it holds a lock for the duration of the call. */
32 void __track_core_alloc(struct proc *p, uint32_t pcoreid);
33
34 /* Track the pcore properly when it is deallocated from p. This code assumes
35  * that the scheduler that uses it holds a lock for the duration of the call.
36  * */
37 void __track_core_dealloc(struct proc *p, uint32_t pcoreid);
38
39 /* Bulk interface for __track_core_dealloc */
40 void __track_core_dealloc_bulk(struct proc *p, uint32_t *pc_arr,
41                                uint32_t nr_cores);
42
43 /* Get/Put an idle core from our pcore list and return its core_id. Don't
44  * consider the chosen core in the future when handing out cores to a
45  * process. This code assumes that the scheduler that uses it holds a lock
46  * for the duration of the call. This will not give out provisioned cores.
47  * The gets return the coreid on success, -1 or -error on failure. */
48 int __get_any_idle_core(void);
49 int __get_specific_idle_core(int coreid);
50 void __put_idle_core(int coreid);
51
52 /* One off functions to make 'pcoreid' the next core chosen by the core
53  * allocation algorithm (so long as no provisioned cores are still idle), and
54  * to sort the idle core list for debugging. This code assumes that the
55  * scheduler that uses it holds a lock for the duration of the call. */
56 void __next_core_to_alloc(uint32_t pcoreid);
57 void __sort_idle_cores(void);
58
59 /* Provision a core to proc p. This code assumes that the scheduler that uses
60  * it holds a lock for the duration of the call. */
61 void __provision_core(struct proc *p, uint32_t pcoreid);
62
63 /* Unprovision all cores from proc p. This code assumes that the scheduler
64  * that uses * it holds a lock for the duration of the call. */
65 void __unprovision_all_cores(struct proc *p);
66
67 /* Print the map of idle cores that are still allocatable through our core
68  * allocation algorithm. */
69 void print_idle_core_map(void);
70
71 /* Print a list of the cores currently provisioned to p. */
72 void print_proc_coreprov(struct proc *p);
73
74 /* Print the processes attached to each provisioned core. */
75 void print_coreprov_map(void);
76
77 static inline struct proc *get_alloc_proc(uint32_t pcoreid)
78 {
79         extern struct sched_pcore *all_pcores;
80
81         return all_pcores[pcoreid].alloc_proc;
82 }
83
84 static inline struct proc *get_prov_proc(uint32_t pcoreid)
85 {
86         extern struct sched_pcore *all_pcores;
87
88         return all_pcores[pcoreid].prov_proc;
89 }
90
91 /* TODO: need more thorough CG/LL management.  For now, core0 is the only LL
92  * core.  This won't play well with the ghetto shit in schedule_init() if you do
93  * anything like 'DEDICATED_MONITOR' or the ARSC server.  All that needs an
94  * overhaul. */
95 static inline bool is_ll_core(uint32_t pcoreid)
96 {
97         if (pcoreid == 0)
98                 return TRUE;
99         return FALSE;
100 }
101
102 /* Normally it'll be the max number of CG cores ever */
103 static inline uint32_t max_vcores(struct proc *p)
104 {
105 /* TODO: (CG/LL) */
106 #ifdef CONFIG_DISABLE_SMT
107         return num_cores >> 1;
108 #else
109         return num_cores - 1;   /* reserving core 0 */
110 #endif /* CONFIG_DISABLE_SMT */
111 }