74c91e8a419f5d559a19f13fd6b0940a1fe39f05
[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 /* The core request algorithm maintains an internal array of these: the
11  * global pcore map. Note the prov_proc and alloc_proc are weak (internal)
12  * references, and should only be used as a ref source while the ksched has a
13  * valid kref. */
14 struct sched_pcore {
15         TAILQ_ENTRY(sched_pcore)   prov_next;    /* on a proc's prov list */
16         TAILQ_ENTRY(sched_pcore)   alloc_next;   /* on an alloc list (idle)*/
17         struct proc                *prov_proc;   /* who this is prov to */
18         struct proc                *alloc_proc;  /* who this is alloc to */
19 };
20 TAILQ_HEAD(sched_pcore_tailq, sched_pcore);
21
22 struct core_request_data {
23         struct sched_pcore_tailq  prov_alloc_me;      /* prov cores alloced us */
24         struct sched_pcore_tailq  prov_not_alloc_me;  /* maybe alloc to others */
25 };
26
27 /* Initialize any data assocaited with doing core allocation. */
28 void corealloc_init(void);
29
30 /* Initialize any data associated with provisiong cores to a process. */
31 void coreprov_proc_init(struct proc *p);
32
33 /* Find the best core to allocate to a process as dictated by the core
34  * allocation algorithm. This code assumes that the scheduler that uses it
35  * holds a lock for the duration of the call. */
36 struct sched_pcore *__find_best_core_to_alloc(struct proc *p);
37
38 /* Track the pcore properly when it is allocated to p. This code assumes that
39  * the scheduler that uses it holds a lock for the duration of the call. */
40 void __track_core_alloc(struct proc *p, uint32_t pcoreid);
41
42 /* Track the pcore properly when it is deallocated from p. This code assumes
43  * that the scheduler that uses it holds a lock for the duration of the call.
44  * */
45 void __track_core_dealloc(struct proc *p, uint32_t pcoreid);
46
47 /* Bulk interface for __track_core_dealloc */
48 void __track_core_dealloc_bulk(struct proc *p, uint32_t *pc_arr,
49                                uint32_t nr_cores);
50
51 /* Get/Put an idle core from our pcore list and return its core_id. Don't
52  * consider the chosen core in the future when handing out cores to a
53  * process. This code assumes that the scheduler that uses it holds a lock
54  * for the duration of the call. This will not give out provisioned cores.
55  * The gets return the coreid on success, -1 or -error on failure. */
56 int __get_any_idle_core(void);
57 int __get_specific_idle_core(int coreid);
58 void __put_idle_core(int coreid);
59
60 /* One off functions to make 'pcoreid' the next core chosen by the core
61  * allocation algorithm (so long as no provisioned cores are still idle), and
62  * to sort the idle core list for debugging. This code assumes that the
63  * scheduler that uses it holds a lock for the duration of the call. */
64 void __next_core_to_alloc(uint32_t pcoreid);
65 void __sort_idle_cores(void);
66
67 /* Provision a core to proc p. This code assumes that the scheduler that uses
68  * it holds a lock for the duration of the call. */
69 void __provision_core(struct proc *p, struct sched_pcore *spc);
70
71 /* Unprovision all cores from proc p. This code assumes that the scheduler
72  * that uses * it holds a lock for the duration of the call. */
73 void __unprovision_all_cores(struct proc *p);
74
75 /* Print a list of the cores currently provisioned to p. */
76 void print_proc_coreprov(struct proc *p);
77
78 /* Print the processes attached to each provisioned core. */
79 void print_coreprov_map(void);
80
81 static inline uint32_t spc2pcoreid(struct sched_pcore *spc)
82 {
83         extern struct sched_pcore *all_pcores;
84
85         return spc - all_pcores;
86 }
87
88 static inline struct sched_pcore *pcoreid2spc(uint32_t pcoreid)
89 {
90         extern struct sched_pcore *all_pcores;
91
92         return &all_pcores[pcoreid];
93 }
94
95 static inline struct proc *get_alloc_proc(struct sched_pcore *c)
96 {
97         return c->alloc_proc;
98 }
99
100 static inline struct proc *get_prov_proc(struct sched_pcore *c)
101 {
102         return c->prov_proc;
103 }