c/libuv
1
0
Fork 0
mirror of https://github.com/libuv/libuv synced 2025-03-28 21:13:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

unix, windows: add uv_loop_init and uv_loop_close

Browse Source 
These functions supersede uv_loop_new and uv_loop_delete.
uv_loop_init initialized a user allocated loop and uv_loop_close
removes all associated resources a loop uses after it has finished
execution.

uv_loop_new and uv_loop_delete are now deprecated.
This commit is contained in:
Saúl Ibarra Corretgé 2014-02-17 22:37:20 +01:00
parent bfba45d285
commit 787f5fff92
13 changed files with 194 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Makefile.am
View File

@ -147,6 +147,7 @@ test_run_tests_SOURCES = test/blackhole-server.c \
test/test-list.h \
test/test-loop-handles.c \
test/test-loop-alive.c \
test/test-loop-close.c \
test/test-loop-stop.c \
test/test-loop-time.c \
test/test-multiple-listen.c \

30
include/uv.h
View File

@ -245,21 +245,43 @@ UV_EXTERN const char* uv_version_string(void);
/*
* This function must be called before any other functions in libuv.
*
* All functions besides uv_run() are non-blocking.
*
* All callbacks in libuv are made asynchronously. That is they are never
* made by the function that takes them as a parameter.
*/
UV_EXTERN uv_loop_t* uv_loop_new(void);
UV_EXTERN void uv_loop_delete(uv_loop_t*);
/*
* Returns the default loop.
*/
UV_EXTERN uv_loop_t* uv_default_loop(void);
/*
* Initializes a uv_loop_t structure.
*/
UV_EXTERN int uv_loop_init(uv_loop_t* loop);
/*
* Closes all internal loop resources. This function must only be called once
* the loop has finished it's execution or it will return UV_EBUSY. After this
* function returns the user shall free the memory allocated for the loop.
*/
UV_EXTERN int uv_loop_close(uv_loop_t* loop);
/*
* Allocates and initializes a new loop.
* NOTE: This function is DEPRECATED (to be removed after 0.12), users should
* allocate the loop and use uv_loop_init instead.
*/
UV_EXTERN uv_loop_t* uv_loop_new(void);
/*
* Cleans up a loop once it has finished executio and frees its memory.
* NOTE: This function is DEPRECATED. Users should use uv_loop_close and free
* the memory themselves instead.
*/
UV_EXTERN void uv_loop_delete(uv_loop_t*);
/*
* This function runs the event loop. It will act differently depending on the
* specified mode:

42
src/unix/loop.c
View File

@ -28,7 +28,7 @@
#include <unistd.h>
static int uv__loop_init(uv_loop_t* loop, int default_loop);
static void uv__loop_delete(uv_loop_t* loop);
static void uv__loop_close(uv_loop_t* loop);
static uv_loop_t default_loop_struct;
static uv_loop_t* default_loop_ptr;
@ -46,6 +46,31 @@ uv_loop_t* uv_default_loop(void) {
}
int uv_loop_init(uv_loop_t* loop) {
return uv__loop_init(loop, /* default_loop? */ 0);
}
int uv_loop_close(uv_loop_t* loop) {
QUEUE* q;
uv_handle_t* h;
if (!QUEUE_EMPTY(&(loop)->active_reqs))
return -EBUSY;
QUEUE_FOREACH(q, &loop->handle_queue) {
h = QUEUE_DATA(q, uv_handle_t, handle_queue);
if (!(h->flags & UV__HANDLE_INTERNAL))
return -EBUSY;
}
uv__loop_close(loop);
#ifndef NDEBUG
memset(loop, -1, sizeof(*loop));
#endif
if (loop == default_loop_ptr)
default_loop_ptr = NULL;
return 0;
}
uv_loop_t* uv_loop_new(void) {
uv_loop_t* loop;
@ -53,7 +78,7 @@ uv_loop_t* uv_loop_new(void) {
if (loop == NULL)
return NULL;
if (uv__loop_init(loop, /* default_loop? */ 0)) {
if (uv_loop_init(loop)) {
free(loop);
return NULL;
}
@ -63,13 +88,10 @@ uv_loop_t* uv_loop_new(void) {
void uv_loop_delete(uv_loop_t* loop) {
uv__loop_delete(loop);
#ifndef NDEBUG
memset(loop, -1, sizeof(*loop));
#endif
if (loop == default_loop_ptr)
default_loop_ptr = NULL;
else
uv_loop_t* default_loop;
default_loop = default_loop_ptr;
uv_loop_close(loop);
if (loop != default_loop)
free(loop);
}
@ -134,7 +156,7 @@ static int uv__loop_init(uv_loop_t* loop, int default_loop) {
}
static void uv__loop_delete(uv_loop_t* loop) {
static void uv__loop_close(uv_loop_t* loop) {
uv__signal_loop_cleanup(loop);
uv__platform_loop_delete(loop);
uv__async_stop(loop, &loop->async_watcher);

61
src/win/core.c
View File

@ -116,12 +116,14 @@ static void uv_init(void) {
}
static void uv_loop_init(uv_loop_t* loop) {
int uv_loop_init(uv_loop_t* loop) {
/* Initialize libuv itself first */
uv__once_init();
/* Create an I/O completion port */
loop->iocp = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 1);
if (loop->iocp == NULL) {
uv_fatal_error(GetLastError(), "CreateIoCompletionPort");
}
if (loop->iocp == NULL)
return uv_translate_sys_error(GetLastError());
/* To prevent uninitialized memory access, loop->time must be intialized */
/* to zero before calling uv_update_time for the first time. */
@ -154,6 +156,8 @@ static void uv_loop_init(uv_loop_t* loop) {
loop->timer_counter = 0;
loop->stop_flag = 0;
return 0;
}
@ -177,35 +181,50 @@ uv_loop_t* uv_default_loop(void) {
}
int uv_loop_close(uv_loop_t* loop) {
QUEUE* q;
uv_handle_t* h;
if (!QUEUE_EMPTY(&(loop)->active_reqs))
return UV_EBUSY;
QUEUE_FOREACH(q, &loop->handle_queue) {
h = QUEUE_DATA(q, uv_handle_t, handle_queue);
if (!(h->flags & UV__HANDLE_INTERNAL))
return UV_EBUSY;
}
if (loop != &uv_default_loop_) {
int i;
for (i = 0; i < ARRAY_SIZE(loop->poll_peer_sockets); i++) {
SOCKET sock = loop->poll_peer_sockets[i];
if (sock != 0 && sock != INVALID_SOCKET)
closesocket(sock);
}
}
/* TODO: cleanup default loop*/
return 0;
}
uv_loop_t* uv_loop_new(void) {
uv_loop_t* loop;
/* Initialize libuv itself first */
uv__once_init();
loop = (uv_loop_t*)malloc(sizeof(uv_loop_t));
if (!loop) {
uv_fatal_error(ERROR_OUTOFMEMORY, "malloc");
if (loop == NULL) {
return NULL;
}
if (uv_loop_init(loop)) {
free(loop);
return NULL;
}
uv_loop_init(loop);
return loop;
}
void uv_loop_delete(uv_loop_t* loop) {
if (loop != &uv_default_loop_) {
int i;
for (i = 0; i < ARRAY_SIZE(loop->poll_peer_sockets); i++) {
SOCKET sock = loop->poll_peer_sockets[i];
if (sock != 0 && sock != INVALID_SOCKET) {
closesocket(sock);
}
}
uv_loop_close(loop);
if (loop != &uv_default_loop_)
free(loop);
}
}

10
test/benchmark-async.c
View File

@ -28,7 +28,7 @@
#define NUM_PINGS (1000 * 1000)
struct ctx {
uv_loop_t* loop;
uv_loop_t loop;
uv_thread_t thread;
uv_async_t main_async; /* wake up main thread */
uv_async_t worker_async; /* wake up worker */
@ -67,7 +67,8 @@ static void main_async_cb(uv_async_t* handle, int status) {
static void worker(void* arg) {
struct ctx* ctx = arg;
ASSERT(0 == uv_async_send(&ctx->main_async));
ASSERT(0 == uv_run(ctx->loop, UV_RUN_DEFAULT));
ASSERT(0 == uv_run(&ctx->loop, UV_RUN_DEFAULT));
uv_loop_close(&ctx->loop);
}
@ -83,9 +84,8 @@ static int test_async(int nthreads) {
for (i = 0; i < nthreads; i++) {
ctx = threads + i;
ctx->nthreads = nthreads;
ctx->loop = uv_loop_new();
ASSERT(ctx->loop != NULL);
ASSERT(0 == uv_async_init(ctx->loop, &ctx->worker_async, worker_async_cb));
ASSERT(0 == uv_loop_init(&ctx->loop));
ASSERT(0 == uv_async_init(&ctx->loop, &ctx->worker_async, worker_async_cb));
ASSERT(0 == uv_async_init(uv_default_loop(),
&ctx->main_async,
main_async_cb));

13
test/benchmark-multi-accept.c
View File

@ -249,27 +249,26 @@ static void get_listen_handle(uv_loop_t* loop, uv_stream_t* server_handle) {
static void server_cb(void *arg) {
struct server_ctx *ctx;
uv_loop_t* loop;
uv_loop_t loop;
ctx = arg;
loop = uv_loop_new();
ASSERT(loop != NULL);
ASSERT(0 == uv_loop_init(&loop));
ASSERT(0 == uv_async_init(loop, &ctx->async_handle, sv_async_cb));
ASSERT(0 == uv_async_init(&loop, &ctx->async_handle, sv_async_cb));
uv_unref((uv_handle_t*) &ctx->async_handle);
/* Wait until the main thread is ready. */
uv_sem_wait(&ctx->semaphore);
get_listen_handle(loop, (uv_stream_t*) &ctx->server_handle);
get_listen_handle(&loop, (uv_stream_t*) &ctx->server_handle);
uv_sem_post(&ctx->semaphore);
/* Now start the actual benchmark. */
ASSERT(0 == uv_listen((uv_stream_t*) &ctx->server_handle,
128,
sv_connection_cb));
ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT));
ASSERT(0 == uv_run(&loop, UV_RUN_DEFAULT));
uv_loop_delete(loop);
uv_loop_close(&loop);
}

11
test/test-embed.c
View File

@ -108,15 +108,14 @@ static void embed_timer_cb(uv_timer_t* timer, int status) {
TEST_IMPL(embed) {
#if defined(HAVE_KQUEUE) || defined(HAVE_EPOLL)
uv_loop_t* external;
uv_loop_t external;
external = uv_loop_new();
ASSERT(external != NULL);
ASSERT(0 == uv_loop_init(&external));
embed_timer_called = 0;
embed_closed = 0;
uv_async_init(external, &embed_async, embed_cb);
uv_async_init(&external, &embed_async, embed_cb);
/* Start timer in default loop */
uv_timer_init(uv_default_loop(), &embed_timer);
@ -127,10 +126,10 @@ TEST_IMPL(embed) {
uv_thread_create(&embed_thread, embed_thread_runner, NULL);
/* But run external loop */
uv_run(external, UV_RUN_DEFAULT);
uv_run(&external, UV_RUN_DEFAULT);
uv_thread_join(&embed_thread);
uv_loop_delete(external);
uv_loop_close(&external);
ASSERT(embed_timer_called == 1);
#endif

13
test/test-fs-event.c
View File

@ -653,7 +653,7 @@ static void fs_event_error_report_close_cb(uv_handle_t* handle) {
TEST_IMPL(fs_event_error_reporting) {
unsigned int i;
uv_loop_t* loops[1024];
uv_loop_t loops[1024];
uv_fs_event_t events[ARRAY_SIZE(loops)];
uv_loop_t* loop;
uv_fs_event_t* event;
@ -668,11 +668,10 @@ TEST_IMPL(fs_event_error_reporting) {
* fail.
*/
for (i = 0; i < ARRAY_SIZE(loops); i++) {
loop = uv_loop_new();
loop = &loops[i];
ASSERT(0 == uv_loop_init(loop));
event = &events[i];
ASSERT(loop != NULL);
loops[i] = loop;
timer_cb_called = 0;
close_cb_called = 0;
ASSERT(0 == uv_fs_event_init(loop, event));
@ -697,7 +696,7 @@ TEST_IMPL(fs_event_error_reporting) {
/* Stop and close all events, and destroy loops */
do {
loop = loops[i];
loop = &loops[i];
event = &events[i];
ASSERT(0 == uv_fs_event_stop(event));
@ -708,9 +707,7 @@ TEST_IMPL(fs_event_error_reporting) {
uv_run(loop, UV_RUN_DEFAULT);
ASSERT(close_cb_called == 1);
uv_loop_delete(loop);
loops[i] = NULL;
uv_loop_close(loop);
} while (i-- != 0);
remove("watch_dir/");

2
test/test-list.h
View File

@ -25,6 +25,7 @@ TEST_DECLARE (close_order)
TEST_DECLARE (run_once)
TEST_DECLARE (run_nowait)
TEST_DECLARE (loop_alive)
TEST_DECLARE (loop_close)
TEST_DECLARE (loop_stop)
TEST_DECLARE (loop_update_time)
TEST_DECLARE (barrier_1)
@ -261,6 +262,7 @@ TASK_LIST_START
TEST_ENTRY (run_once)
TEST_ENTRY (run_nowait)
TEST_ENTRY (loop_alive)
TEST_ENTRY (loop_close)
TEST_ENTRY (loop_stop)
TEST_ENTRY (loop_update_time)
TEST_ENTRY (barrier_1)

54
test/test-loop-close.c Normal file
View File

@ -0,0 +1,54 @@
/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*/
#include "uv.h"
#include "task.h"
static uv_timer_t timer_handle;
static void timer_cb(uv_timer_t* handle, int status) {
ASSERT(handle);
ASSERT(status == 0);
uv_stop(handle->loop);
}
TEST_IMPL(loop_close) {
int r;
uv_loop_t loop;
ASSERT(0 == uv_loop_init(&loop));
uv_timer_init(&loop, &timer_handle);
uv_timer_start(&timer_handle, timer_cb, 100, 100);
ASSERT(UV_EBUSY == uv_loop_close(&loop));
uv_run(&loop, UV_RUN_DEFAULT);
uv_close((uv_handle_t*) &timer_handle, NULL);
r = uv_run(&loop, UV_RUN_DEFAULT);
ASSERT(r == 0);
ASSERT(0 == uv_loop_close(&loop));
return 0;
}

26
test/test-signal-multiple-loops.c
View File

@ -84,28 +84,27 @@ static void signal_handling_worker(void* context) {
uv_signal_t signal1a;
uv_signal_t signal1b;
uv_signal_t signal2;
uv_loop_t* loop;
uv_loop_t loop;
int r;
action = (enum signal_action) (uintptr_t) context;
loop = uv_loop_new();
ASSERT(loop != NULL);
ASSERT(0 == uv_loop_init(&loop));
/* Setup the signal watchers and start them. */
if (action == ONLY_SIGUSR1 || action == SIGUSR1_AND_SIGUSR2) {
r = uv_signal_init(loop, &signal1a);
r = uv_signal_init(&loop, &signal1a);
ASSERT(r == 0);
r = uv_signal_start(&signal1a, signal1_cb, SIGUSR1);
ASSERT(r == 0);
r = uv_signal_init(loop, &signal1b);
r = uv_signal_init(&loop, &signal1b);
ASSERT(r == 0);
r = uv_signal_start(&signal1b, signal1_cb, SIGUSR1);
ASSERT(r == 0);
}
if (action == ONLY_SIGUSR2 || action == SIGUSR1_AND_SIGUSR2) {
r = uv_signal_init(loop, &signal2);
r = uv_signal_init(&loop, &signal2);
ASSERT(r == 0);
r = uv_signal_start(&signal2, signal2_cb, SIGUSR2);
ASSERT(r == 0);
@ -117,7 +116,7 @@ static void signal_handling_worker(void* context) {
/* Wait for all signals. The signal callbacks stop the watcher, so uv_run
* will return when all signal watchers caught a signal.
*/
r = uv_run(loop, UV_RUN_DEFAULT);
r = uv_run(&loop, UV_RUN_DEFAULT);
ASSERT(r == 0);
/* Restart the signal watchers. */
@ -136,7 +135,7 @@ static void signal_handling_worker(void* context) {
/* Wait for signals once more. */
uv_sem_post(&sem);
r = uv_run(loop, UV_RUN_DEFAULT);
r = uv_run(&loop, UV_RUN_DEFAULT);
ASSERT(r == 0);
/* Close the watchers. */
@ -150,10 +149,10 @@ static void signal_handling_worker(void* context) {
}
/* Wait for the signal watchers to close. */
r = uv_run(loop, UV_RUN_DEFAULT);
r = uv_run(&loop, UV_RUN_DEFAULT);
ASSERT(r == 0);
uv_loop_delete(loop);
uv_loop_close(&loop);
}
@ -166,12 +165,13 @@ static void loop_creating_worker(void* context) {
(void) context;
do {
uv_loop_t* loop;
uv_loop_t *loop;
uv_signal_t signal;
int r;
loop = uv_loop_new();
loop = malloc(sizeof(*loop));
ASSERT(loop != NULL);
ASSERT(0 == uv_loop_init(loop));
r = uv_signal_init(loop, &signal);
ASSERT(r == 0);
@ -184,7 +184,7 @@ static void loop_creating_worker(void* context) {
r = uv_run(loop, UV_RUN_DEFAULT);
ASSERT(r == 0);
uv_loop_delete(loop);
uv_loop_close(loop);
increment_counter(&loop_creation_counter);
} while (!stop);

6
test/test-thread.c
View File

@ -112,8 +112,9 @@ static void do_work(void* arg) {
int r;
struct test_thread* thread = arg;
loop = uv_loop_new();
loop = malloc(sizeof *loop);
ASSERT(loop != NULL);
ASSERT(0 == uv_loop_init(loop));
for (i = 0; i < ARRAY_SIZE(getaddrinfo_reqs); i++) {
struct getaddrinfo_req* req = getaddrinfo_reqs + i;
@ -132,7 +133,8 @@ static void do_work(void* arg) {
r = uv_run(loop, UV_RUN_DEFAULT);
ASSERT(r == 0);
uv_loop_delete(loop);
ASSERT(0 == uv_loop_close(loop));
free(loop);
thread->thread_called = 1;
}

1
uv.gyp
View File

@ -326,6 +326,7 @@
'test/test-list.h',
'test/test-loop-handles.c',
'test/test-loop-alive.c',
'test/test-loop-close.c',
'test/test-loop-stop.c',
'test/test-loop-time.c',
'test/test-walk-handles.c',