Thread diversion awaiting log call return

Patent metadata

Field	Value
Publication number	US-10140150-B2
Application number	US-201615018531-A
Country	US
Kind code	B2
Filing date	Feb 8, 2016
Priority date	Feb 8, 2016
Publication date	Nov 27, 2018
Grant date	Nov 27, 2018

Abstract

The efficient use of threads that issue calls to log events. While waiting for the call to return or complete, the threads are put to work on other tasks that are not part of the process that generated the event. This can occur without context switching of the thread, especially when the task to be performed is state-less or context free. In the efficient thread diversion process, the thread calls a logging component to log an event. This blocks the thread from continuing work on a process that the event is part of until the event is logged. The thread then performs a diversion task that is not part of the processing unit that the event is part of. After detecting that the event has logged, the thread continues work on the processing unit that the event is part of.

First claim

What is claimed is:

1. A system comprising:
one or more processors; and
one or more computer-readable storage media having stored thereon computer-executable instructions that are executable by the one or more processors of the system to perform one or more tasks while waiting for an event to be logged, the computer-executable instructions including instructions to perform the following:
execute, at the one or more processors, a plurality of threads including a particular thread, each of the plurality of threads alternately executing at the one or more processors;
during an execution time period allocated to the particular thread, call, from the particular thread, a logging component to log an event;
after calling the logging component to log the event, block the particular thread from continuing work on a first task of which the event is part until the event has been determined to be logged;
after blocking the particular thread from continuing work on the first task, determine that there is time left in the execution time period allocated to the particular thread; and
based on there being time left in the execution time period, automatically perform, by the particular thread, one or more second tasks that are context-free or stateless, and that are independent of the first task of which the event is part;
determine that the event has been logged; and
after determining that the event has been logged, continue work, by the particular thread, on the first task of which the event is part.

2. The system in accordance with claim 1 , wherein the one or more second tasks are selected from a diversion task library that includes a plurality of tasks that may be completed by threads that await a determination that the logging component has completed the logging of the event corresponding to the call.

3. The system in accordance with claim 2 , the diversion task library comprising a plurality of groups of tasks, each of the groups of tasks corresponding to an expected processing time range.

4. The system in accordance with claim 3 , wherein the one or more second tasks are selected from one of the plurality of groups of tasks having an expected processing time range that is approximately equal to or less than an estimated expected latency between a time of the call and a time of the determination that the event has been logged.

5. The system in accordance with claim 1 , the one or more second tasks including a garbage collection task.

6. The system in accordance with claim 1 , the event being determined to be logged by the call to the logging component being returned.

7. The system in accordance with claim 1 , the event being determined to be logged by polling the logging component.

8. A method, implemented at a computer system that includes one or more processors, for performing one or more tasks while waiting for an event to be logged, the method comprising:
executing, at the one or more processors, a plurality of threads including a particular thread, each of the plurality of threads alternately executing at the one or more processors;
during an execution time period allocated to the particular thread, calling, from the particular thread, a logging component to log an event;
after calling the logging component to log the event, blocking the particular thread from continuing work on a first task of which the event is part until the event has been determined to be logged;
after blocking the particular thread from continuing work on the first task, determining that there is time left in the execution time period allocated to the particular thread; and
based on there being time left in the execution time period, automatically performing, by the particular thread, one or more second tasks that are context-free or stateless, and that are independent of the processing unit of which the event is part;
determining that the event has been logged; and
after determining that the event has been logged, continuing work, by the particular thread, on the first task of which the event is part.

9. The method in accordance with claim 8 , at least one of the one or more second tasks being pausable and resumable.

10. The method in accordance with claim 8 , the method further comprising:
selecting the one or more second tasks from a plurality of tasks that collectively have a predictable processing time range.

11. The method in accordance with claim 10 , the predictable processing time range being equal to or less than an expected latency between a time of the call and a time of the determination that the event has been logged.

12. The method in accordance with claim 8 , the method further comprising:
estimating an expected latency between a time of the call and a time of the determination that the event has been logged; and
selecting the one or more second tasks from a plurality of tasks that have a collective predictable processing time range that is equal to or less than the estimated expected latency between the time of the call and the time of the determination that the event has been logged.

13. The method in accordance with claim 12 , the expected latency between the time of the call and the time of the call return being 50 microseconds or less.

14. The method in accordance with claim 12 , the expected latency between the time of the call and the time of the call return being 25 microseconds or less.

15. The method in accordance with claim 8 further comprising the following before determining that the event has been logged:
completing, by the particular thread, the one or more second tasks that are independent of the first task of which the event is part.

16. The method in accordance with claim 8 , further comprising the following before continuing work on the processing unit of which the event is part:
pausing, by the particular thread, at least one of the one or more second tasks that are independent of the first task of which the event is part.

17. The method in accordance with claim 8 , automatically performing the one or more second tasks comprising:
resuming a previously paused task that is independent of the first task of which the event is part.

18. A computer program product comprising one or more computer-readable storage media having thereon computer-executable instructions that are executable by one or more processors of a computing system to perform one or more tasks while waiting for an event to be logged, the computer-executable instructions further including instructions to configure the computing system to perform at least the following:
execute, at the one or more processors, a plurality of threads including a particular thread, each of the plurality of threads alternately executing at the one or more processors;
during an execution time period allocated to the particular thread, call, from the particular thread, a logging component to log an event;
after calling the logging component to log the event, block the particular thread from continuing work on a first task of which the event is part until the event has been determined to be logged;
after blocking the particular thread from continuing work on the first task, determine that there is time left in the execution time period allocated to the particular thread; and
based on there being time left in the execution time period, automatically perform, by the particular thread, one or more second tasks that are context-free or stateless, and that are independent of the first task of which the event is part;
determine that the event has been logged; and
after determining that the

Assignees

• Microsoft Technology Licensing Llc

Inventors

• Fitzgerald Robert Patrick
• Diaconu Cristian
• Zwilling Michael James
• Larson Per-Ake

Classifications

• G06F9/4843 Primary

  by program, e.g. task dispatcher, supervisor, operating system · CPC title