Move coreprov_proc_init() to corealloc_proc_init()
[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 #endif
15
16 /* Initialize any data assocaited with doing core allocation. */
17 void corealloc_init(void);
18
19 /* Initialize any data associated with allocating cores to a process. */
20 void corealloc_proc_init(struct proc *p);
21
22 /* Find the best core to allocate to a process as dictated by the core
23  * allocation algorithm. This code assumes that the scheduler that uses it
24  * holds a lock for the duration of the call. */
25 struct sched_pcore *__find_best_core_to_alloc(struct proc *p);
26
27 /* Track the pcore properly when it is allocated to p. This code assumes that
28  * the scheduler that uses it holds a lock for the duration of the call. */
29 void __track_core_alloc(struct proc *p, uint32_t pcoreid);
30
31 /* Track the pcore properly when it is deallocated from p. This code assumes
32  * that the scheduler that uses it holds a lock for the duration of the call.
33  * */
34 void __track_core_dealloc(struct proc *p, uint32_t pcoreid);
35
36 /* Bulk interface for __track_core_dealloc */
37 void __track_core_dealloc_bulk(struct proc *p, uint32_t *pc_arr,
38                                uint32_t nr_cores);
39
40 /* Get/Put an idle core from our pcore list and return its core_id. Don't
41  * consider the chosen core in the future when handing out cores to a
42  * process. This code assumes that the scheduler that uses it holds a lock
43  * for the duration of the call. This will not give out provisioned cores.
44  * The gets return the coreid on success, -1 or -error on failure. */
45 int __get_any_idle_core(void);
46 int __get_specific_idle_core(int coreid);
47 void __put_idle_core(int coreid);
48
49 /* One off functions to make 'pcoreid' the next core chosen by the core
50  * allocation algorithm (so long as no provisioned cores are still idle), and
51  * to sort the idle core list for debugging. This code assumes that the
52  * scheduler that uses it holds a lock for the duration of the call. */
53 void __next_core_to_alloc(uint32_t pcoreid);
54 void __sort_idle_cores(void);
55
56 /* Provision a core to proc p. This code assumes that the scheduler that uses
57  * it holds a lock for the duration of the call. */
58 void __provision_core(struct proc *p, struct sched_pcore *spc);
59
60 /* Unprovision all cores from proc p. This code assumes that the scheduler
61  * that uses * it holds a lock for the duration of the call. */
62 void __unprovision_all_cores(struct proc *p);
63
64 /* Print the map of idle cores that are still allocatable through our core
65  * allocation algorithm. */
66 void print_idle_core_map(void);
67
68 /* Print a list of the cores currently provisioned to p. */
69 void print_proc_coreprov(struct proc *p);
70
71 /* Print the processes attached to each provisioned core. */
72 void print_coreprov_map(void);
73
74 /* TODO: need more thorough CG/LL management.  For now, core0 is the only LL
75  * core.  This won't play well with the ghetto shit in schedule_init() if you do
76  * anything like 'DEDICATED_MONITOR' or the ARSC server.  All that needs an
77  * overhaul. */
78 static inline bool is_ll_core(uint32_t pcoreid)
79 {
80         if (pcoreid == 0)
81                 return TRUE;
82         return FALSE;
83 }
84
85 /* Normally it'll be the max number of CG cores ever */
86 static inline uint32_t max_vcores(struct proc *p)
87 {
88 /* TODO: (CG/LL) */
89 #ifdef CONFIG_DISABLE_SMT
90         return num_cores >> 1;
91 #else
92         return num_cores - 1;   /* reserving core 0 */
93 #endif /* CONFIG_DISABLE_SMT */
94 }