Advanced OS, resource management, process management

1. CS 704DAdvanced Operating System( Resource & Process Management) Debasis Das

2. Resource and Process Management IT 703D Debasis Das

5. Tasks are assigned to suitable nodes

6. Load balancing approach

7. Processes are distributed so as to balance load on nodes

8. Load sharing approach

10. Dynamic in nature

11. Quick decision making capability

12. Balanced system performance and scheduling overhead

13. Stability

14. Scalability

15. Fault tolerance

17. Process is already broken into tasks

18. Amount of computation required by a task and speed of processing at nodes are known

19. Cost of processing at each node is known

20. IPC costs between every pair of tasks are known

21. Resource requirements of tasks, availability at each node and precedence of tasks are known

23. Quick turn around for a process

24. High degree of parallelism

26. Algorithms available

27. Static vs. dynamic

28. Average known performance taken into consideration rather than instantaneous figures

29. Deterministic vs. probabilistic

30. A static approach. Processor assignment to a node is fixed.

31. Centralized vs. distributed

32. A dynamic method. A centralized server may decide assignments. K servers will make assignments in a decentralized approach

33. Cooperative vs. non cooperative

35. How the load on a node is estimated

36. Process transfer policy

37. Basis of executing a process locally or at a remote node

38. State information exchange policy

39. How state information should be exchanged

40. Priority assignment policy

41. Priority of local and remote processes at a node

42. Migration limiting policy

44. No. of processes at the node

45. Resource demand of these active processes

46. Instruction mixes of these processes

48. Predetermined threshold is considered depending on the processing capability

49. Dynamic

50. Threshold is calculated as a product of the average workload of all nodes. State information is exchanged to determine the threshold at any time

52. Threshold

53. Pick a node at random, check a threshold and then assign if under-loaded

54. Shortest

55. Pick p nodes at random, assign to the node with lightest node

56. Bidding

57. Each node has a manager and a contractor role. A node that needs service broadcasts need. Contractors bid. Winning bidder gets the process

58. Pairing

60. Network traffic increases, not scalable, useless information(no change) many a times

61. Broadcast when state changes

62. Additionally, one can broadcast only when overloaded or under-loaded

63. On-demand exchange

64. Only when under-loaded or overloaded

65. Exchange by polling

67. Rules used could be

68. Selfish

69. Local processes get higher priority

70. Altruistic

71. Remote processes get higher priority

72. Intermediate

74. Any process arriving at a node is welcome. Can cause instability

75. Controlled

77. Load estimation policies

78. Process transfer policies

79. Location policies

80. Sender-initiated location policies

81. Receiver initiated location policy

82. State information Exchange policies

83. Broadcast when state changes

85. There may be several processes running on current distributed systems

87. A overloaded node may broadcast for a lightly loaded node or poll nodes

88. Receiver initiated policies

90. State information request message is sent out only when a node goes belo9w/above threshold

91. Poll when state changes

92. Poll only when the state changes.

95. Important concepts in this regard,

96. Processor allocation: which process goes to which processor

97. Process migration: should the process be migrated to some other processor

99. Selection of a process to be migrated

100. Selection of destination node

101. Actual transfer of the process

102. Actual time taken when the process is being transferred is “freezing time”, the process is stopped

103. Preemptive and non-preemptive transfers

104. Process migrated before it has started is non-preemptive

106. Object access level: allows easy non preemptive migration if object level(files, devices) is available. Processes can be initiated at any arbitrary node. Naming needs to be location independent

107. System call and IPC level: system calls & IPC need to be system/location independent . This then can support pre-emptive migration

108. Minimal Interference : minimal freezing time

109. Minimal residual dependencies: once a process migrates, there should not be any dependency left in the source system

110. Efficiency: time & cost to be minimal

111. Robustness: other than failure of the current execution node, nothing else should matter

113. Freezing on source node, restarting on destination node

114. Transferring of process address space

115. Forwarding messages meant for the process migrated

117. Immediate & delayed blocking of processes

118. Fast & slow I/O operations

119. Reinstating the process on destination node

120. Address space transfer

121. Total freezing

122. Pre-transferring

124. Blocking at source can take place only when

125. Process is not executing a system call, block immediately

126. Process is executing a system call and sleeping at a interruptible priority level, block immediately.

128. Waiting for slow I/O such as terminal I/O may not be feasible.

129. Some means of continuing slow I/O after migration will be required

130. Information about open files

131. A link to the open file is created

133. In some implementations this may have a different process id for a while

134. After the migration happens completely the id may be changed to the original id and the original process deleted

136. Process’s address space that includes code, data and stack

138. Source process is frozen until not only the process but also address space transfer is complete, takes a longer freeze time

139. Pre-transferring

140. Address space transfer is completed before the source process is frozen and migration completed

141. Transfer on reference

143. Messages that arrive after source process is frozen but the destination process has not started

144. Message at source node after the process has started at destination node

145. Messages to the migrant process after the execution at destination has started

146. Resending the message mechanism

147. Drop the message, let the senders retransmit messages again after locating the destination process

148. Origin site mechanism

149. Each node receiving message for processes on it, keep track of the migration and forward messages

150. Link traversal mechanism

151. First type are located in a queue and forwarded along with address space. A link left at source node lets the messages of type 2 &3 to be forwarded.

152. Link update mechanism

154. Disallow migration of a processes whose children are yet to complete

155. When a process does migrate, ensure all the children go with it

156. Home node or origin site concept

158. An external data representation is created

159. Floating point numbers are, typically, need the most consideration in creating the representation. Following need to be considered very closely

160. Exponent handling

161. Mantissa handling

163. Speeding up individual jobs

164. Gaining higher throughput

165. Utilizing resources effectively

166. Reducing network traffic

167. Improving system reliability

170. Share an address space & open files, global variable, child processes, semaphores, signals, accounting information and other OS resources

171. Motivations in using threads

172. Models for organizing threads

173. Issues in designing a threads package

175. Switching threads has lower overhead that process/task switching

176. Threads allow parallelism to be combined with sequential execution with blocking system calls

178. Single dispatcher, multiple workers. Dispatcher accepts requests and hands over the work to a free worker. Similar kind of service calls can be parallelized.

179. Team model

180. All threads are equal. Could be like a collection of specialized threads that can service several types of services in parallel.

181. Pipeline model

183. Static or dynamic. Static calls create all the threads required at compile time. While dynamic creation creates threads as needed through a system call. Stack size is a parameter along with scheduling priority and the process that includes the thread . System call returns a thread id

184. Threads termination

185. Exit call to kill itself or a specific external kill command given the thread id.

186. Threads synchronization

187. Threads scheduling

189. Use critical regions that only one thread can enter at a time.

190. Access is controlled by mutex variable, works as of way of the following

191. Threads are blocked and enters a queue waiting on the mutex OR

192. Return an error code indicating access is not possible. The thread can decide to continue with something else but needs to acquire the lock to get access

194. Priority based assignment; can be non-preemptive or preemptive

195. Vary quantum size dynamically

196. Vary the quantum of the time slice in a round robin scheme dynamically. Vary the quantum inversely with the number of threads present in the system

197. Handoff scheduling

198. One thread relinquishing the CPU designated which thread it should be given to. A sender, for example, can request that the receiver thread be handed over the processor.

199. Affinity scheduling

201. Typically a routine within the process handles it to ensure that

202. Signals should not get lost. Exceptions can interfere, overwrite global variables

204. A runtime system manages threads, a status information table is also maintained. Each entry has state of thread, registers, priority etc.

205. Scheduling via kernel for the process, then the runtime divides the time quantum to the threads in the process

206. Kernel level

208. Two level scheduling provides scheduling flexibility

209. Switching is faster in user level package as the run time rather than the kernel does it

210. On user level a thread can be stopped only if the process is stopped as the process containing the thread only can be stopped by the kernel

211. Threads should not be allowed to make blocking system calls as it’ll block the process. Jacket calls can be used