-
Notifications
You must be signed in to change notification settings - Fork 52
New issue
Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.
By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.
Already on GitHub? Sign in to your account
utubettl: slow take #228
Comments
DerekBum
added a commit
that referenced
this issue
Apr 28, 2024
If some of the utube for tasks at the start of the tube were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, but by the cost of slowing the `put` method (it ~3 times slower). Thus, this workaround is disabled by default. To enable it, user should set the `v2 = true` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utube', {temporary = true, v2 = true}) ``` Part of #228
DerekBum
added a commit
that referenced
this issue
Apr 28, 2024
If some of the utube for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method (it is ~3 times slower). Thus, this workaround is disabled by default. To enable it, user should set the `v2 = true` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utube', {temporary = true, v2 = true}) ``` Part of #228
DerekBum
added a commit
that referenced
this issue
Apr 28, 2024
If some of the utube for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method (it is ~3 times slower). Thus, this workaround is disabled by default. To enable it, user should set the `v2 = true` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utube', {temporary = true, v2 = true}) ``` Part of #228
DerekBum
added a commit
that referenced
this issue
Apr 28, 2024
If some of the utube for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method (it is ~3 times slower). Thus, this workaround is disabled by default. To enable it, user should set the `v2 = true` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utube', {temporary = true, v2 = true}) ``` Part of #228
DerekBum
added a commit
that referenced
this issue
May 6, 2024
If some of the utube for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method (it is ~3 times slower). Thus, this workaround is disabled by default. To enable it, user should set the `v2 = true` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utube', {temporary = true, v2 = true}) ``` Part of #228
DerekBum
added a commit
that referenced
this issue
May 7, 2024
If some of the utube for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method (it is ~3 times slower). Thus, this workaround is disabled by default. To enable it, user should set the `v2 = true` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utube', {temporary = true, v2 = true}) ``` Part of #228
DerekBum
added a commit
that referenced
this issue
May 8, 2024
If some of the utube for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method (it is ~3 times slower). Thus, this workaround is disabled by default. To enable it, user should set the `v2 = true` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utube', {temporary = true, v2 = true}) ``` Part of #228
DerekBum
added a commit
that referenced
this issue
May 8, 2024
If some of the utubettl for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method (it is ~3 times slower). Thus, this workaround is disabled by default. To enable it, user should set the `v2 = true` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utubettl', {temporary = true, v2 = true}) ``` Closes #228
DerekBum
added a commit
that referenced
this issue
May 9, 2024
If some of the utube for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method (it is ~3 times slower). Thus, this workaround is disabled by default. To enable it, user should set the `v2 = true` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utube', {temporary = true, v2 = true}) ``` Part of #228
DerekBum
added a commit
that referenced
this issue
May 9, 2024
If some of the utubettl for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method (it is ~3 times slower). Thus, this workaround is disabled by default. To enable it, user should set the `v2 = true` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utubettl', {temporary = true, v2 = true}) ``` Closes #228
DerekBum
added a commit
that referenced
this issue
May 9, 2024
If some of the utube for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method (it is ~3 times slower). Thus, this workaround is disabled by default. To enable it, user should set the `v2 = true` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utube', {temporary = true, v2 = true}) ``` Part of #228
DerekBum
added a commit
that referenced
this issue
May 9, 2024
If some of the utubettl for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method (it is ~3 times slower). Thus, this workaround is disabled by default. To enable it, user should set the `v2 = true` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utubettl', {temporary = true, v2 = true}) ``` Closes #228
DerekBum
added a commit
that referenced
this issue
May 13, 2024
If some of the utube for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method (it is ~3 times slower). Thus, this workaround is disabled by default. To enable it, user should set the `policy = "utube_ready_space"` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utube', {temporary = true, policy = "utube_ready_space"}) ``` Part of #228
DerekBum
added a commit
that referenced
this issue
May 13, 2024
If some of the utubettl for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method (it is ~3 times slower). Thus, this workaround is disabled by default. To enable it, user should set the `policy = "utube_ready_space"` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utubettl', {temporary = true, policy = "utube_ready_space"}) ``` Closes #228
DerekBum
added a commit
that referenced
this issue
May 13, 2024
If some of the utube for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method (it is ~3 times slower). Thus, this workaround is disabled by default. To enable it, user should set the `policy = "utube_ready_space"` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utube', {temporary = true, policy = "utube_ready_space"}) ``` Part of #228
DerekBum
added a commit
that referenced
this issue
May 13, 2024
If some of the utubettl for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method (it is ~3 times slower). Thus, this workaround is disabled by default. To enable it, user should set the `policy = "utube_ready_space"` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utubettl', {temporary = true, policy = "utube_ready_space"}) ``` Closes #228
DerekBum
added a commit
that referenced
this issue
May 13, 2024
If some of the utube for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method (it is ~3 times slower). Thus, this workaround is disabled by default. To enable it, user should set the `storage_mode = "utube_ready_space"` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utube', {temporary = true, storage_mode = "utube_ready_space"}) ``` Part of #228
DerekBum
added a commit
that referenced
this issue
May 13, 2024
If some of the utubettl for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method (it is ~3 times slower). Thus, this workaround is disabled by default. To enable it, user should set the `storage_mode = "utube_ready_space"` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utubettl', {temporary = true, storage_mode = "utube_ready_space"}) ``` Closes #228
DerekBum
added a commit
that referenced
this issue
May 14, 2024
If some of the utube for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method (it is ~3 times slower). Thus, this workaround is disabled by default. To enable it, user should set the `storage_mode = queue.driver.utube.STORAGE_MODE_UTUBE_READY_SPACE` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utube', {temporary = true, storage_mode = queue.driver.utube.STORAGE_MODE_UTUBE_READY_SPACE}) ``` Part of #228
DerekBum
added a commit
that referenced
this issue
May 14, 2024
If some of the utubettl for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method (it is ~3 times slower). Thus, this workaround is disabled by default. To enable it, user should set the `storage_mode = queue.driver.utubettl.STORAGE_MODE_UTUBE_READY_SPACE` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utubettl', {temporary = true, storage_mode = queue.driver.utubettl.STORAGE_MODE_UTUBE_READY_SPACE}) ``` Closes #228
DerekBum
added a commit
that referenced
this issue
May 14, 2024
If some of the utube for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method (it is ~3 times slower). Thus, this workaround is disabled by default. To enable it, user should set the `storage_mode = queue.driver.utube.STORAGE_MODE_UTUBE_READY_SPACE` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utube', {temporary = true, storage_mode = queue.driver.utube.STORAGE_MODE_UTUBE_READY_SPACE}) ``` Part of #228
DerekBum
added a commit
that referenced
this issue
May 14, 2024
If some of the utubettl for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method (it is ~3 times slower). Thus, this workaround is disabled by default. To enable it, user should set the `storage_mode = queue.driver.utubettl.STORAGE_MODE_UTUBE_READY_SPACE` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utubettl', {temporary = true, storage_mode = queue.driver.utubettl.STORAGE_MODE_UTUBE_READY_SPACE}) ``` Closes #228
DerekBum
added a commit
that referenced
this issue
May 14, 2024
If some of the utube for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method (it is ~3 times slower). Thus, this workaround is disabled by default. To enable it, user should set the `storage_mode = queue.driver.utube.STORAGE_MODE_UTUBE_READY_SPACE` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utube', {temporary = true, storage_mode = queue.driver.utube.STORAGE_MODE_UTUBE_READY_SPACE}) ``` Part of #228
DerekBum
added a commit
that referenced
this issue
May 14, 2024
If some of the utubettl for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method (it is ~3 times slower). Thus, this workaround is disabled by default. To enable it, user should set the `storage_mode = queue.driver.utubettl.STORAGE_MODE_UTUBE_READY_SPACE` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utubettl', {temporary = true, storage_mode = queue.driver.utubettl.STORAGE_MODE_UTUBE_READY_SPACE}) ``` Closes #228
DerekBum
added a commit
that referenced
this issue
May 15, 2024
If some of the utube for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method (it is ~3 times slower). Thus, this workaround is disabled by default. To enable it, user should set the `storage_mode = queue.driver.utube.STORAGE_MODE_UTUBE_READY_SPACE` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utube', {temporary = true, storage_mode = queue.driver.utube.STORAGE_MODE_UTUBE_READY_SPACE}) ``` Part of #228
DerekBum
added a commit
that referenced
this issue
May 15, 2024
If some of the utubettl for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method (it is ~3 times slower). Thus, this workaround is disabled by default. To enable it, user should set the `storage_mode = queue.driver.utubettl.STORAGE_MODE_UTUBE_READY_SPACE` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utubettl', {temporary = true, storage_mode = queue.driver.utubettl.STORAGE_MODE_UTUBE_READY_SPACE}) ``` Closes #228
DerekBum
added a commit
that referenced
this issue
May 16, 2024
If some of the utube for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready_buffer`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method. Thus, this workaround is disabled by default. To enable it, user should set the `storage_mode = queue.driver.utube.STORAGE_MODE_READY_BUFFER` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utube', {temporary = true, storage_mode = queue.driver.utube.STORAGE_MODE_READY_BUFFER}) ``` Part of #228
DerekBum
added a commit
that referenced
this issue
May 16, 2024
If some of the utubettl for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready_buffer`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method. Thus, this workaround is disabled by default. To enable it, user should set the `storage_mode = queue.driver.utubettl.STORAGE_MODE_READY_BUFFER` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utubettl', {temporary = true, storage_mode = queue.driver.utubettl.STORAGE_MODE_READY_BUFFER}) ``` Closes #228
DerekBum
added a commit
that referenced
this issue
May 16, 2024
If some of the utubettl for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready_buffer`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method. Thus, this workaround is disabled by default. To enable it, user should set the `storage_mode = queue.driver.utubettl.STORAGE_MODE_READY_BUFFER` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utubettl', {temporary = true, storage_mode = queue.driver.utubettl.STORAGE_MODE_READY_BUFFER}) ``` Closes #228
DerekBum
added a commit
that referenced
this issue
May 16, 2024
If some of the utubettl for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready_buffer`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method. Thus, this workaround is disabled by default. To enable it, user should set the `storage_mode = queue.driver.utubettl.STORAGE_MODE_READY_BUFFER` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utubettl', {temporary = true, storage_mode = queue.driver.utubettl.STORAGE_MODE_READY_BUFFER}) ``` Closes #228
DerekBum
added a commit
that referenced
this issue
May 16, 2024
If some of the utubettl for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready_buffer`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method. Thus, this workaround is disabled by default. To enable it, user should set the `storage_mode = queue.driver.utubettl.STORAGE_MODE_READY_BUFFER` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utubettl', {temporary = true, storage_mode = queue.driver.utubettl.STORAGE_MODE_READY_BUFFER}) ``` Closes #228
DerekBum
added a commit
that referenced
this issue
May 17, 2024
If some of the utube for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready_buffer`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method. Thus, this workaround is disabled by default. To enable it, user should set the `storage_mode = queue.driver.utube.STORAGE_MODE_READY_BUFFER` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utube', {temporary = true, storage_mode = queue.driver.utube.STORAGE_MODE_READY_BUFFER}) ``` Part of #228
DerekBum
added a commit
that referenced
this issue
May 17, 2024
If some of the utubettl for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready_buffer`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method. Thus, this workaround is disabled by default. To enable it, user should set the `storage_mode = queue.driver.utubettl.STORAGE_MODE_READY_BUFFER` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utubettl', {temporary = true, storage_mode = queue.driver.utubettl.STORAGE_MODE_READY_BUFFER}) ``` Closes #228
DerekBum
added a commit
that referenced
this issue
May 17, 2024
If some of the utube for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready_buffer`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method. Thus, this workaround is disabled by default. To enable it, user should set the `storage_mode = queue.driver.utube.STORAGE_MODE_READY_BUFFER` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utube', {temporary = true, storage_mode = queue.driver.utube.STORAGE_MODE_READY_BUFFER}) ``` Part of #228
DerekBum
added a commit
that referenced
this issue
May 17, 2024
If some of the utubettl for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready_buffer`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method. Thus, this workaround is disabled by default. To enable it, user should set the `storage_mode = queue.driver.utubettl.STORAGE_MODE_READY_BUFFER` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utubettl', {temporary = true, storage_mode = queue.driver.utubettl.STORAGE_MODE_READY_BUFFER}) ``` Closes #228
DerekBum
added a commit
that referenced
this issue
May 17, 2024
If some of the utube for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready_buffer`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method. Thus, this workaround is disabled by default. To enable it, user should set the `storage_mode = queue.driver.utube.STORAGE_MODE_READY_BUFFER` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utube', {temporary = true, storage_mode = queue.driver.utube.STORAGE_MODE_READY_BUFFER}) ``` Part of #228
DerekBum
added a commit
that referenced
this issue
May 17, 2024
If some of the utubettl for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready_buffer`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method. Thus, this workaround is disabled by default. To enable it, user should set the `storage_mode = queue.driver.utubettl.STORAGE_MODE_READY_BUFFER` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utubettl', {temporary = true, storage_mode = queue.driver.utubettl.STORAGE_MODE_READY_BUFFER}) ``` Closes #228
DerekBum
added a commit
that referenced
this issue
May 17, 2024
If some of the utubettl for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready_buffer`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method. Thus, this workaround is disabled by default. To enable it, user should set the `storage_mode = queue.driver.utubettl.STORAGE_MODE_READY_BUFFER` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utubettl', {temporary = true, storage_mode = queue.driver.utubettl.STORAGE_MODE_READY_BUFFER}) ``` Closes #228
DerekBum
added a commit
that referenced
this issue
May 17, 2024
If some of the utube for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready_buffer`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method. Thus, this workaround is disabled by default. To enable it, user should set the `storage_mode = queue.driver.utube.STORAGE_MODE_READY_BUFFER` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utube', {temporary = true, storage_mode = queue.driver.utube.STORAGE_MODE_READY_BUFFER}) ``` Part of #228
DerekBum
added a commit
that referenced
this issue
May 17, 2024
If some of the utubettl for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready_buffer`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method. Thus, this workaround is disabled by default. To enable it, user should set the `storage_mode = queue.driver.utubettl.STORAGE_MODE_READY_BUFFER` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utubettl', {temporary = true, storage_mode = queue.driver.utubettl.STORAGE_MODE_READY_BUFFER}) ``` Closes #228
DerekBum
added a commit
that referenced
this issue
May 17, 2024
If some of the utube for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready_buffer`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method. Thus, this workaround is disabled by default. To enable it, user should set the `storage_mode = queue.driver.utube.STORAGE_MODE_READY_BUFFER` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utube', {temporary = true, storage_mode = queue.driver.utube.STORAGE_MODE_READY_BUFFER}) ``` Part of #228
DerekBum
added a commit
that referenced
this issue
May 17, 2024
If some of the utubettl for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready_buffer`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method. Thus, this workaround is disabled by default. To enable it, user should set the `storage_mode = queue.driver.utubettl.STORAGE_MODE_READY_BUFFER` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utubettl', {temporary = true, storage_mode = queue.driver.utubettl.STORAGE_MODE_READY_BUFFER}) ``` Closes #228
oleg-jukovec
pushed a commit
that referenced
this issue
May 18, 2024
If some of the utube for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready_buffer`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method. Thus, this workaround is disabled by default. To enable it, user should set the `storage_mode = queue.driver.utube.STORAGE_MODE_READY_BUFFER` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utube', {temporary = true, storage_mode = queue.driver.utube.STORAGE_MODE_READY_BUFFER}) ``` Part of #228
oleg-jukovec
pushed a commit
that referenced
this issue
May 18, 2024
If some of the utubettl for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready_buffer`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method. Thus, this workaround is disabled by default. To enable it, user should set the `storage_mode = queue.driver.utubettl.STORAGE_MODE_READY_BUFFER` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utubettl', {temporary = true, storage_mode = queue.driver.utubettl.STORAGE_MODE_READY_BUFFER}) ``` Closes #228
oleg-jukovec
pushed a commit
that referenced
this issue
May 18, 2024
If some of the utube for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready_buffer`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method. Thus, this workaround is disabled by default. To enable it, user should set the `storage_mode = queue.driver.utube.STORAGE_MODE_READY_BUFFER` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utube', {temporary = true, storage_mode = queue.driver.utube.STORAGE_MODE_READY_BUFFER}) ``` Part of #228
oleg-jukovec
pushed a commit
that referenced
this issue
May 18, 2024
If some of the utubettl for tasks at the top of the queue were busy most of the time, `take` would slow down for every other task. This problem is fixed by creating a new space `space_ready_buffer`. It contains first task with `READY` status from each utube. This solution shows great results for the stated problem, with the cost of slowing the `put` method. Thus, this workaround is disabled by default. To enable it, user should set the `storage_mode = queue.driver.utubettl.STORAGE_MODE_READY_BUFFER` as an option while creating the tube. As example: ```lua local test_queue = queue.create_tube('test_queue', 'utubettl', {temporary = true, storage_mode = queue.driver.utubettl.STORAGE_MODE_READY_BUFFER}) ``` Closes #228
Merged
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Our clients reported that
utubettl:take()
loads CPU too much and takes too much time when there is autube
with a big amount of tasks (+100.000).utubettl
driver and 5-10utube
s with ~50.000 tasks + 5-10 parallel clients with take() + ack(). It will help to identify the problem.utube
s (10.000) with a small number of tasks on each (4-5) + 5-10 parallel clients with take() + ack(). This way we can make sure that our fix doesn't degrade performance.I suggest to make the task in the order:
The text was updated successfully, but these errors were encountered: