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