Statistics
| Branch: | Revision:

grapes / include / scheduler_la.h @ master

History | View | Annotate | Download (7.61 KB)

1 4f4e8c34 Luca Abeni
#ifndef SCHEDULER_LA_H
2
#define SCHEDULER_LA_H
3
4
#include "scheduler_common.h"
5
6
/** @file scheduler_la.h
7 b9e0d721 MarcoBiazzini
  @brief Low level scheduling functions for chunk and peer selection.
8 4f4e8c34 Luca Abeni

9
  The interface contains highly customizable selector functions. Customization is supported along the following concepts:
10
        -# evaluator functions: selector functions can be parameterized by evaluator functions.
11
                By using evaluator functions, the decision process can be decoupled into two parts:
12
                -# a generic selector function operating on abstract peer and chunk weights
13
                -# the evaluator function linking the decision process to the peer's knowledge about other peers and chunks
14
        -# selection policy: ChunkFirst, PeerFirst, Composed and Hybrid selection policies are supported
15
        -# ordering method: two kinds of ordering methods are supported:
16
                -# Best: strict ordering accorging to the given evaluator functions
17
                -# Weighted: Weighted random selection accorging to the given weight functions
18
        -# filter functions: selections are typically filtered by functions such as whether a given peer (according to local knowledge) needs a given chunk.
19
                The abstraction of the filter concept allows for easy modification of these filter conditions.
20
*/
21
22
/**
23
  * Scheduler ordering methods
24
  */
25
typedef enum {SCHED_BEST,SCHED_WEIGHTED} SchedOrdering;
26
27
/**
28 85c4b598 MarcoBiazzini
  * @brief Prototype for filter functions that select useful peer-chunk combinations
29
  * @return true if the combination is valid, false otherwise
30 4f4e8c34 Luca Abeni
  */
31 0fb056cf Csaba Kiraly
typedef int (*filterFunction)(schedPeerID ,schedChunkID );
32 4f4e8c34 Luca Abeni
33
/**
34 85c4b598 MarcoBiazzini
  * @brief Prototype for function assigning a weigth to a peer
35
  * @return the weight associated to the peer
36 4f4e8c34 Luca Abeni
  */
37 0fb056cf Csaba Kiraly
typedef double (*peerEvaluateFunction)(schedPeerID*);
38 4f4e8c34 Luca Abeni
39
/**
40 85c4b598 MarcoBiazzini
  * @brief Prototype for function assigning a weigth to a given chunk
41
  * @return the weight associated to the chunk
42 4f4e8c34 Luca Abeni
  */
43 0fb056cf Csaba Kiraly
typedef double (*chunkEvaluateFunction)(schedChunkID*);
44 4f4e8c34 Luca Abeni
45
/**
46 85c4b598 MarcoBiazzini
  * @brief Prototype for function assigning a weigth to a peer-chunk pair
47
  * @return the weight associated to the peer-chunk pair
48 4f4e8c34 Luca Abeni
  */
49
typedef double (*pairEvaluateFunction)(struct PeerChunk*);
50
51
/**
52 85c4b598 MarcoBiazzini
  * @brief Prototype for a two operand double function used to combine weights
53 4f4e8c34 Luca Abeni
  */
54
typedef double (*double2op)(double,double);
55
56
57
58
/**
59 85c4b598 MarcoBiazzini
  @brief Low level scheduler function for selecting peers.
60 4f4e8c34 Luca Abeni

61
  If called with chunks_len=0, it will not consider chunks in the selection.
62
  Otherwise, if chunks_len>0, only those peers will be selected that could be interesting for at least one of the given chunks.
63

64
  @param [in] ordering the ordering method to be used
65
  @param [in] peers list of peers to select from
66
  @param [in] peers_len length of peers list
67
  @param [in] chunk list of chunks to select from
68
  @param [in] chunks_len length of chunks list
69
  @param [out] selected list of peers selected by the function
70
  @param [in,out] selected_len in: maximum number of peers to select; out: number of peers selected
71
  @param [in] filter only peers that satisfy the filter condition can be selected
72
  @param [in] peerevaluate peers are selected based on the weight assigned by this evaluator function
73
 */
74 0fb056cf Csaba Kiraly
void schedSelectPeers(SchedOrdering ordering, schedPeerID  *peers, int peers_len, schedChunkID  *chunks, int chunks_len,         //in
75
                     schedPeerID  *selected, int *selected_len,        //out, inout
76 4f4e8c34 Luca Abeni
                     filterFunction filter,
77
                     peerEvaluateFunction peerevaluate);
78
79
/**
80 85c4b598 MarcoBiazzini
  @brief Low level scheduler function for selecting chunks.
81 4f4e8c34 Luca Abeni

82
  If called with peers_len=0, it will not consider peers in the selection.
83
  Otherwise, if peers_len>0, only those chunks will be selected that could be interesting for at least one of the given peers.
84

85
 */
86 0fb056cf Csaba Kiraly
void schedSelectChunks(SchedOrdering ordering, schedPeerID  *peers, int peers_len, schedChunkID  *chunks, int chunks_len,         //in
87
                     schedChunkID  *selected, int *selected_len,        //out, inout
88 4f4e8c34 Luca Abeni
                     filterFunction filter,
89
                     chunkEvaluateFunction chunkevaluate);
90
91
/*---PeerFirst----------------*/
92
93
/**
94 85c4b598 MarcoBiazzini
  @brief Low level scheduler function for selecting peer-chunk pairs in chunk first order.
95 4f4e8c34 Luca Abeni

96
  First a peer is selected based on weights assigned by the peerevaluate function.
97
  Then, maximum selected_len chunks are selected for the given peer based on weights assigned by the chunkevaluate function.
98
  */
99 0fb056cf Csaba Kiraly
void schedSelectPeerFirst(SchedOrdering ordering, schedPeerID  *peers, size_t peers_len, schedChunkID  *chunks, size_t chunks_len,         //in
100 4f4e8c34 Luca Abeni
                     struct PeerChunk *selected, size_t *selected_len,        //out, inout
101
                     filterFunction filter,
102
                     peerEvaluateFunction peerevaluate, chunkEvaluateFunction chunkevaluate);
103
104
/*---ChunkFirst----------------*/
105
106
/**
107 85c4b598 MarcoBiazzini
  * @brief Low level scheduler function for selecting peer-chunk pairs in peer first order.
108 4f4e8c34 Luca Abeni

109
  First a chunk is selected based on weights assigned by the chunkevaluate function.
110
  Then, maximum selected_len peers are selected for the given chunk based on weights assigned by the peerevaluate function.
111
  */
112 0fb056cf Csaba Kiraly
void schedSelectChunkFirst(SchedOrdering ordering, schedPeerID  *peers, size_t peers_len, schedChunkID  *chunks, size_t chunks_len,         //in
113 4f4e8c34 Luca Abeni
                     struct PeerChunk *selected, size_t *selected_len,        //out, inout
114
                     filterFunction filter,
115
                     peerEvaluateFunction peerevaluate, chunkEvaluateFunction chunkevaluate);
116
117
/*---Composed----------------*/
118
119
/**
120 85c4b598 MarcoBiazzini
  * @brief Low level scheduler function for selecting peer-chunk pairs based on a composed evaluation function.
121 4f4e8c34 Luca Abeni

122
  A maximum of selected_len peer-chunk pairs are selected based on a composed weight function.
123
  @param [in] chunkevaluate function to assign a weight to each chunk
124
  @param [in] peerevaluate function to assign a weight to each peer
125
  @param [in] weightcombine operation to combine peer and chunk weight into one weight
126
  */
127 0fb056cf Csaba Kiraly
void schedSelectComposed(SchedOrdering ordering, schedPeerID  *peers, size_t peers_len, schedChunkID  *chunks, size_t chunks_len,         //in
128 4f4e8c34 Luca Abeni
                     struct PeerChunk *selected, size_t *selected_len,        //out, inout
129
                     filterFunction filter,
130
                     peerEvaluateFunction peerevaluate, chunkEvaluateFunction chunkevaluate, double2op weightcombine);
131
132 cda1653e ArpadBakay
/*---PeersForChunks----------------*/
133
/** 
134
  * @brief Added by Arpad without knowing what he is doing
135
   Documentation: see above
136

137
  */
138
void schedSelectPeersForChunks(SchedOrdering ordering, schedPeerID *peers, size_t peers_len, schedChunkID *chunks, size_t chunks_len,        //in
139
                     schedPeerID *selected, size_t *selected_len,       //out, inout
140
                     filterFunction filter,
141
                     peerEvaluateFunction evaluate);
142
143 4f4e8c34 Luca Abeni
/*---Hybrid----------------*/
144
145
/**
146 85c4b598 MarcoBiazzini
  * @brief Low level scheduler function for selecting peer-chunk pairs based on a hybrid evaluation function.
147 4f4e8c34 Luca Abeni

148
  A maximum of selected_len peer-chunk pairs are selected based on the given evaluation function.
149
  @param [in] pairevaluate function to assign a weight to each peer-chunk pair
150
  */
151 0fb056cf Csaba Kiraly
void schedSelectHybrid(SchedOrdering ordering, schedPeerID  *peers, size_t peers_len, schedChunkID  *chunks, size_t chunks_len,         //in
152 4f4e8c34 Luca Abeni
                     struct PeerChunk *selected, size_t *selected_len,        //out, inout
153
                     filterFunction filter,
154
                     pairEvaluateFunction pairevaluate);
155
156 d242a2c6 napawine
157
/*---selector function----------------*/
158
/**
159
  * casted evaluator for generic use in generic selector functions
160
  */
161
typedef double (*evaluateFunction)(void*);
162
163
/**
164
  * Select best N of K with the given ordering method
165
  */
166
void selectWithOrdering(SchedOrdering ordering, size_t size, unsigned char *base, size_t nmemb, double(*evaluate)(void *), unsigned char *selected,size_t *selected_len);
167
168 4f4e8c34 Luca Abeni
#endif /* SCHEDULER_LA_H */