Skip to content

Commit 5289339

Browse files
colombodcolombod
committed
new scheduler api
1 parent a88095e commit 5289339

File tree

2 files changed

+322
-135
lines changed

2 files changed

+322
-135
lines changed

‎src/Microsoft.DotNet.Interactive.Tests/KernelCommandSchedulerTests.cs‎

Lines changed: 195 additions & 135 deletions
Original file line numberDiff line numberDiff line change
@@ -50,164 +50,224 @@ private void DisposeAfterTest(Action action)
5050
}
5151

5252
[Fact]
53-
public async Task command_execute_on_kernel_specified_at_scheduling_time()
53+
public async Task scheduled_work_is_completed_in_order()
5454
{
55-
var commandsHandledOnKernel1 = new List<KernelCommand>();
56-
var commandsHandledOnKernel2 = new List<KernelCommand>();
55+
var scheduler = new KernelScheduler<int, int>();
5756

58-
var scheduler = new KernelCommandScheduler();
57+
var executionList = new List<int>();
5958

60-
var kernel1 = new FakeKernel("kernel1")
61-
{
62-
Handle = (command, _) =>
63-
{
64-
commandsHandledOnKernel1.Add(command);
65-
return Task.CompletedTask;
66-
}
67-
};
68-
var kernel2 = new FakeKernel("kernel2")
69-
{
70-
Handle = (command, _) =>
71-
{
72-
commandsHandledOnKernel2.Add(command);
73-
return Task.CompletedTask;
74-
}
75-
};
59+
await scheduler.Schedule(1, (v) => executionList.Add(v));
60+
await scheduler.Schedule(2, (v) => executionList.Add(v));
61+
await scheduler.Schedule(3, (v) => executionList.Add(v));
7662

77-
var command1 = new SubmitCode("for kernel 1");
78-
var command2 = new SubmitCode("for kernel 2");
7963

80-
await scheduler.Schedule(command1, kernel1);
81-
await scheduler.Schedule(command2, kernel2);
64+
executionList.Should().BeEquivalentSequenceTo(1, 2, 3);
65+
}
8266

83-
commandsHandledOnKernel1.Should().ContainSingle().Which.Should().Be(command1);
84-
commandsHandledOnKernel2.Should().ContainSingle().Which.Should().Be(command2);
67+
[Fact]
68+
public void scheduled_work_does_not_execute_in_parallel()
69+
{
70+
throw new NotImplementedException();
8571
}
8672

8773
[Fact]
88-
public async Task scheduling_a_command_will_defer_deferred_commands_scheduled_on_same_kernel()
74+
public async Task deferred_work_is_executed_before_new_work()
8975
{
90-
var commandsHandledOnKernel1 = new List<KernelCommand>();
76+
var executionList = new List<int>();
9177

92-
var scheduler = new KernelCommandScheduler();
78+
var scheduler = new KernelScheduler<int, int>();
79+
scheduler.RegisterDeferredOperationSource(
80+
v => Enumerable.Repeat(v * 10, v), (v) => executionList.Add(v));
9381

94-
var kernel1 = new FakeKernel("kernel1")
95-
{
96-
Handle = (command, _) =>
97-
{
98-
commandsHandledOnKernel1.Add(command);
99-
return Task.CompletedTask;
100-
}
101-
};
102-
var kernel2 = new FakeKernel("kernel2")
103-
{
104-
Handle = (_, _) => Task.CompletedTask
105-
};
106-
107-
var deferredCommand1 = new SubmitCode("deferred for kernel 1");
108-
var deferredCommand2 = new SubmitCode("deferred for kernel 2");
109-
var deferredCommand3 = new SubmitCode("deferred for kernel 1");
110-
var command1 = new SubmitCode("for kernel 1");
82+
11183

112-
scheduler.DeferCommand(deferredCommand1, kernel1);
113-
scheduler.DeferCommand(deferredCommand2, kernel2);
114-
scheduler.DeferCommand(deferredCommand3, kernel1);
115-
await scheduler.Schedule(command1, kernel1);
84+
await scheduler.Schedule(1, (v) => executionList.Add(v));
85+
await scheduler.Schedule(2, (v) => executionList.Add(v));
86+
await scheduler.Schedule(3, (v) => executionList.Add(v));
11687

117-
commandsHandledOnKernel1.Should().NotContain(deferredCommand2);
118-
commandsHandledOnKernel1.Should().BeEquivalentSequenceTo(deferredCommand1, deferredCommand3, command1);
88+
executionList.Should().BeEquivalentSequenceTo(10,1,20,20, 2,30,30,30, 3);
11989
}
12090

12191
[Fact]
122-
public async Task deferred_command_not_executed_are_still_in_deferred_queue()
92+
public async Task awaiting_one_operation_does_not_wait_all()
12393
{
124-
var commandsHandledOnKernel1 = new List<KernelCommand>();
125-
var commandsHandledOnKernel2 = new List<KernelCommand>();
94+
var executionList = new List<int>();
12695

127-
var scheduler = new KernelCommandScheduler();
96+
var scheduler = new KernelScheduler<int, int>();
12897

129-
var kernel1 = new FakeKernel("kernel1")
130-
{
131-
Handle = (command, _) =>
132-
{
133-
commandsHandledOnKernel1.Add(command);
134-
return Task.CompletedTask;
135-
}
136-
};
137-
var kernel2 = new FakeKernel("kernel2")
138-
{
139-
Handle = (command, _) =>
140-
{
141-
commandsHandledOnKernel2.Add(command);
142-
return Task.CompletedTask;
143-
}
144-
};
145-
146-
var deferredCommand1 = new SubmitCode("deferred for kernel 1");
147-
var deferredCommand2 = new SubmitCode("deferred for kernel 2");
148-
var deferredCommand3 = new SubmitCode("deferred for kernel 1");
149-
var command1 = new SubmitCode("for kernel 1");
150-
var command2 = new SubmitCode("for kernel 2");
151-
152-
scheduler.DeferCommand(deferredCommand1, kernel1);
153-
scheduler.DeferCommand(deferredCommand2, kernel2);
154-
scheduler.DeferCommand(deferredCommand3, kernel1);
155-
await scheduler.Schedule(command1, kernel1);
156-
157-
commandsHandledOnKernel2.Should().BeEmpty();
158-
commandsHandledOnKernel1.Should().NotContain(deferredCommand2);
159-
commandsHandledOnKernel1.Should().BeEquivalentSequenceTo(deferredCommand1, deferredCommand3, command1);
160-
await scheduler.Schedule(command2, kernel2);
161-
commandsHandledOnKernel2.Should().BeEquivalentSequenceTo(deferredCommand2, command2);
98+
99+
await scheduler.Schedule(1, (v) => executionList.Add(v));
100+
await scheduler.Schedule(2, (v) => executionList.Add(v));
101+
scheduler.Schedule(3, (v) => executionList.Add(v));
102+
103+
executionList.Should().BeEquivalentSequenceTo(10, 1, 20, 20, 2);
162104
}
163105

164106
[Fact]
165-
public async Task deferred_command_on_parent_kernel_are_executed_when_scheduling_command_on_child_kernel()
107+
public void new_work_is_executed_after_all_require()
166108
{
167-
var commandHandledList = new List<(KernelCommand command, Kernel kernel)>();
168-
169-
var scheduler = new KernelCommandScheduler();
170-
171-
var childKernel = new FakeKernel("kernel1")
172-
{
173-
Handle = (command, context) => command.InvokeAsync(context)
174-
};
175-
var parentKernel = new CompositeKernel
176-
{
177-
childKernel
178-
};
179-
180-
parentKernel.DefaultKernelName = childKernel.Name;
181-
182-
var deferredCommand1 = new TestCommand((command, context) =>
183-
{
184-
commandHandledList.Add((command, context.HandlingKernel));
185-
return Task.CompletedTask;
186-
}, childKernel.Name);
187-
var deferredCommand2 = new TestCommand((command, context) =>
188-
{
189-
commandHandledList.Add((command, context.HandlingKernel));
190-
return Task.CompletedTask;
191-
}, parentKernel.Name);
192-
var deferredCommand3 = new TestCommand((command, context) =>
193-
{
194-
commandHandledList.Add((command, context.HandlingKernel));
195-
return Task.CompletedTask;
196-
}, childKernel.Name);
197-
var command1 = new TestCommand((command, context) =>
198-
{
199-
commandHandledList.Add((command, context.HandlingKernel));
200-
return Task.CompletedTask;
201-
}, childKernel.Name);
202-
203-
scheduler.DeferCommand(deferredCommand1, childKernel);
204-
scheduler.DeferCommand(deferredCommand2, parentKernel);
205-
scheduler.DeferCommand(deferredCommand3, childKernel);
206-
await scheduler.Schedule(command1, childKernel);
207-
208-
commandHandledList.Select(e => e.command).Should().BeEquivalentSequenceTo(deferredCommand1, deferredCommand2, deferredCommand3, command1);
209-
210-
commandHandledList.Select(e => e.kernel).Should().BeEquivalentSequenceTo(childKernel, parentKernel, childKernel, childKernel);
109+
throw new NotImplementedException();
211110
}
111+
112+
//[Fact]
113+
//public async Task command_execute_on_kernel_specified_at_scheduling_time()
114+
//{
115+
// var commandsHandledOnKernel1 = new List<KernelCommand>();
116+
// var commandsHandledOnKernel2 = new List<KernelCommand>();
117+
118+
// var scheduler = new KernelCommandScheduler();
119+
120+
// var kernel1 = new FakeKernel("kernel1")
121+
// {
122+
// Handle = (command, _) =>
123+
// {
124+
// commandsHandledOnKernel1.Add(command);
125+
// return Task.CompletedTask;
126+
// }
127+
// };
128+
// var kernel2 = new FakeKernel("kernel2")
129+
// {
130+
// Handle = (command, _) =>
131+
// {
132+
// commandsHandledOnKernel2.Add(command);
133+
// return Task.CompletedTask;
134+
// }
135+
// };
136+
137+
// var command1 = new SubmitCode("for kernel 1", kernel1.Name);
138+
// var command2 = new SubmitCode("for kernel 2", kernel2.Name);
139+
140+
// await scheduler.Schedule(command1);
141+
// await scheduler.Schedule(command2);
142+
143+
// commandsHandledOnKernel1.Should().ContainSingle().Which.Should().Be(command1);
144+
// commandsHandledOnKernel2.Should().ContainSingle().Which.Should().Be(command2);
145+
//}
146+
147+
//[Fact]
148+
//public async Task scheduling_a_command_will_defer_deferred_commands_scheduled_on_same_kernel()
149+
//{
150+
// var commandsHandledOnKernel1 = new List<KernelCommand>();
151+
152+
// var scheduler = new KernelCommandScheduler();
153+
154+
// var kernel1 = new FakeKernel("kernel1")
155+
// {
156+
// Handle = (command, _) =>
157+
// {
158+
// commandsHandledOnKernel1.Add(command);
159+
// return Task.CompletedTask;
160+
// }
161+
// };
162+
// var kernel2 = new FakeKernel("kernel2")
163+
// {
164+
// Handle = (_, _) => Task.CompletedTask
165+
// };
166+
167+
// var deferredCommand1 = new SubmitCode("deferred for kernel 1", kernel1.Name);
168+
// var deferredCommand2 = new SubmitCode("deferred for kernel 2", kernel2.Name);
169+
// var deferredCommand3 = new SubmitCode("deferred for kernel 1", kernel1.Name);
170+
// var command1 = new SubmitCode("for kernel 1", kernel1.Name);
171+
172+
// scheduler.DeferCommand(deferredCommand1);
173+
// scheduler.DeferCommand(deferredCommand2);
174+
// scheduler.DeferCommand(deferredCommand3);
175+
// await scheduler.Schedule(command1);
176+
177+
// commandsHandledOnKernel1.Should().NotContain(deferredCommand2);
178+
// commandsHandledOnKernel1.Should().BeEquivalentSequenceTo(deferredCommand1, deferredCommand3, command1);
179+
//}
180+
181+
//[Fact]
182+
//public async Task deferred_command_not_executed_are_still_in_deferred_queue()
183+
//{
184+
// var commandsHandledOnKernel1 = new List<KernelCommand>();
185+
// var commandsHandledOnKernel2 = new List<KernelCommand>();
186+
187+
// var scheduler = new KernelCommandScheduler();
188+
189+
// var kernel1 = new FakeKernel("kernel1")
190+
// {
191+
// Handle = (command, _) =>
192+
// {
193+
// commandsHandledOnKernel1.Add(command);
194+
// return Task.CompletedTask;
195+
// }
196+
// };
197+
// var kernel2 = new FakeKernel("kernel2")
198+
// {
199+
// Handle = (command, _) =>
200+
// {
201+
// commandsHandledOnKernel2.Add(command);
202+
// return Task.CompletedTask;
203+
// }
204+
// };
205+
206+
// var deferredCommand1 = new SubmitCode("deferred for kernel 1");
207+
// var deferredCommand2 = new SubmitCode("deferred for kernel 2");
208+
// var deferredCommand3 = new SubmitCode("deferred for kernel 1");
209+
// var command1 = new SubmitCode("for kernel 1");
210+
// var command2 = new SubmitCode("for kernel 2");
211+
212+
// scheduler.DeferCommand(deferredCommand1, kernel1);
213+
// scheduler.DeferCommand(deferredCommand2, kernel2);
214+
// scheduler.DeferCommand(deferredCommand3, kernel1);
215+
// await scheduler.Schedule(command1, kernel1);
216+
217+
// commandsHandledOnKernel2.Should().BeEmpty();
218+
// commandsHandledOnKernel1.Should().NotContain(deferredCommand2);
219+
// commandsHandledOnKernel1.Should().BeEquivalentSequenceTo(deferredCommand1, deferredCommand3, command1);
220+
// await scheduler.Schedule(command2, kernel2);
221+
// commandsHandledOnKernel2.Should().BeEquivalentSequenceTo(deferredCommand2, command2);
222+
//}
223+
224+
//[Fact]
225+
//public async Task deferred_command_on_parent_kernel_are_executed_when_scheduling_command_on_child_kernel()
226+
//{
227+
// var commandHandledList = new List<(KernelCommand command, Kernel kernel)>();
228+
229+
// var scheduler = new KernelCommandScheduler();
230+
231+
// var childKernel = new FakeKernel("kernel1")
232+
// {
233+
// Handle = (command, context) => command.InvokeAsync(context)
234+
// };
235+
// var parentKernel = new CompositeKernel
236+
// {
237+
// childKernel
238+
// };
239+
240+
// parentKernel.DefaultKernelName = childKernel.Name;
241+
242+
// var deferredCommand1 = new TestCommand((command, context) =>
243+
// {
244+
// commandHandledList.Add((command, context.HandlingKernel));
245+
// return Task.CompletedTask;
246+
// }, childKernel.Name);
247+
// var deferredCommand2 = new TestCommand((command, context) =>
248+
// {
249+
// commandHandledList.Add((command, context.HandlingKernel));
250+
// return Task.CompletedTask;
251+
// }, parentKernel.Name);
252+
// var deferredCommand3 = new TestCommand((command, context) =>
253+
// {
254+
// commandHandledList.Add((command, context.HandlingKernel));
255+
// return Task.CompletedTask;
256+
// }, childKernel.Name);
257+
// var command1 = new TestCommand((command, context) =>
258+
// {
259+
// commandHandledList.Add((command, context.HandlingKernel));
260+
// return Task.CompletedTask;
261+
// }, childKernel.Name);
262+
263+
// scheduler.DeferCommand(deferredCommand1, childKernel);
264+
// scheduler.DeferCommand(deferredCommand2, parentKernel);
265+
// scheduler.DeferCommand(deferredCommand3, childKernel);
266+
// await scheduler.Schedule(command1, childKernel);
267+
268+
// commandHandledList.Select(e => e.command).Should().BeEquivalentSequenceTo(deferredCommand1, deferredCommand2, deferredCommand3, command1);
269+
270+
// commandHandledList.Select(e => e.kernel).Should().BeEquivalentSequenceTo(childKernel, parentKernel, childKernel, childKernel);
271+
//}
212272
}
213-
}
273+
}

0 commit comments

Comments
 (0)