Refactor to move alloc stuff to corealloc.c (3/7)
[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 /* Track the pcore properly when it is allocated to p. This code assumes that
34  * the scheduler that uses it holds a lock for the duration of the call. */
35 void __track_core_alloc(struct proc *p, uint32_t pcoreid);
36
37 /* Track the pcore properly when it is deallocated from p. This code assumes
38  * that the scheduler that uses it holds a lock for the duration of the call.
39  * */
40 void __track_core_dealloc(struct proc *p, uint32_t pcoreid);
41
42 /* Bulk interface for __track_core_dealloc */
43 void __track_core_dealloc_bulk(struct proc *p, uint32_t *pc_arr,
44                                uint32_t nr_cores);
45
46 /* Provision a core to proc p. This code assumes that the scheduler that uses
47  * it holds a lock for the duration of the call. */
48 void __provision_core(struct proc *p, struct sched_pcore *spc);
49
50 /* Unprovision all cores from proc p. This code assumes that the scheduler
51  * that uses * it holds a lock for the duration of the call. */
52 void __unprovision_all_cores(struct proc *p);
53
54 /* Print a list of the cores currently provisioned to p. */
55 void print_proc_coreprov(struct proc *p);
56
57 /* Print the processes attached to each provisioned core. */
58 void print_coreprov_map(void);
59
60 static inline uint32_t spc2pcoreid(struct sched_pcore *spc)
61 {
62         extern struct sched_pcore *all_pcores;
63
64         return spc - all_pcores;
65 }
66
67 static inline struct sched_pcore *pcoreid2spc(uint32_t pcoreid)
68 {
69         extern struct sched_pcore *all_pcores;
70
71         return &all_pcores[pcoreid];
72 }
73
74 static inline struct proc *get_alloc_proc(struct sched_pcore *c)
75 {
76         return c->alloc_proc;
77 }
78
79 static inline struct proc *get_prov_proc(struct sched_pcore *c)
80 {
81         return c->prov_proc;
82 }