Passing variables between phases

arkade · 2016-05-02T09:40:37+00:00

On Monday, May 2, 2016 at 11:21:47 AM UTC-4, jona...@findmeon.com wrote:- you just need to add /usr/local/openresty/nginx to the beginning of your path varia...

Passing variables between phases

arkade

Hi,

The documentation states that ngx.var and ngx.ctx are expensive methods and should be avoided.

What is the recommended way to pass variables between Lua running in different phases. For example:

content_by_lua: do some subrequests. Save some timings

log_by_lua: log timings from subrequests

Is ngx.shared.dict the best option to avoid using ngx.var or ngx.ctx?

rpaprocki

Hey Rob,

Using these API calls is not inherently problematic, just make sure to avoid them on hit code paths. For inter-phase usage ngx.ctx is exactly what you want, the overhead of shared dicts is a waste for your use case. It's important to cache ngx.var and ngx.ctx values when accessing then multiple times in a hot code path. See https://www.cryptobells.com/properly-scoping-lua-nginx-modules-ngx-ctx/ for an emperical analysis.

On May 1, 2016, at 18:40, Rob Kay <ar...@gmail.com> wrote:

Hi,
The documentation states that ngx.var and ngx.ctx are expensive methods and should be avoided.

What is the recommended way to pass variables between Lua running in different phases. For example:

content_by_lua: do some subrequests. Save some timings
log_by_lua: log timings from subrequests

Is ngx.shared.dict the best option to avoid using ngx.var or ngx.ctx?

.

rkelledy

Hi Robert,

Thanks for your quick response. I guess this paragraph just had me worried:

"The ngx.ctx lookup requires relatively expensive metamethod calls and it is much slower than explicitly passing per-request data along by your own function arguments. So do not abuse this API for saving your own function arguments because it usually has quite some performance impact."

The same thing wasn't said for the ngx.shared.dict.

On 2 May 2016 at 11:52, Robert Paprocki <rpap...@fearnothingproductions.net> wrote:

Hey Rob,

Using these API calls is not inherently problematic, just make sure to avoid them on hit code paths. For inter-phase usage ngx.ctx is exactly what you want, the overhead of shared dicts is a waste for your use case. It's important to cache ngx.var and ngx.ctx values when accessing then multiple times in a hot code path. See https://www.cryptobells.com/properly-scoping-lua-nginx-modules-ngx-ctx/ for an emperical analysis.

On May 1, 2016, at 18:40, Rob Kay <ar...@gmail.com> wrote:

Hi,
The documentation states that ngx.var and ngx.ctx are expensive methods and should be avoided.

What is the recommended way to pass variables between Lua running in different phases. For example:

content_by_lua: do some subrequests. Save some timings
log_by_lua: log timings from subrequests

Is ngx.shared.dict the best option to avoid using ngx.var or ngx.ctx?

.

rpaprocki

Yep, had me worried too at first. That's why I ran some testing ;) Obviously these APIs are useful. a single call to ngx.ctx is much faster than a shared dict access. and some information from ngx.var is not available elsewhere, so it's necessary.

The point to take from the documented warnings is to avoid naively calling these API functions redundantly in a hot code path, not "don't use these functions evar!!" :p so for example, don't pass around ngx.ctx like this

=======

function foo(data, val)

data.bar = val -- this directly edits ngx.ctx

end

foo(ngx.ctx, 1)

foo(ngx.ctx, 2)

foo(ngx.ctx, 3)

=======

Instead, pass your own local data around:

=======

-- t is a local copy of ngx.ctx

local t = ngx.ctx

function foo(data, val)

data.bar = val

end

foo(t, 1) -- still passing a table to foo()

foo(t, 2)

foo(t, 3)

[...snip...]

-- save the local table back to ngx.ctx

-- do this at the end of your handler or wherever

-- you're done working with ngx.ctx

ngx.ctx = t

=======

Note the above example is only really valid when you're making a LOT of accesses to ngx.ctx, otherwise it's just harmful premature optimization ;)

On May 1, 2016, at 19:12, Rob Kelledy <rke...@gmail.com> wrote:

Hi Robert,
Thanks for your quick response. I guess this paragraph just had me worried:

"The ngx.ctx lookup requires relatively expensive metamethod calls and it is much slower than explicitly passing per-request data along by your own function arguments. So do not abuse this API for saving your own function arguments because it usually has quite some performance impact."

The same thing wasn't said for the ngx.shared.dict.

On 2 May 2016 at 11:52, Robert Paprocki <rpap...@fearnothingproductions.net> wrote:
Hey Rob,

Using these API calls is not inherently problematic, just make sure to avoid them on hit code paths. For inter-phase usage ngx.ctx is exactly what you want, the overhead of shared dicts is a waste for your use case. It's important to cache ngx.var and ngx.ctx values when accessing then multiple times in a hot code path. See https://www.cryptobells.com/properly-scoping-lua-nginx-modules-ngx-ctx/ for an emperical analysis.

On May 1, 2016, at 18:40, Rob Kay <ar...@gmail.com> wrote:

Hi,
The documentation states that ngx.var and ngx.ctx are expensive methods and should be avoided.

What is the recommended way to pass variables between Lua running in different phases. For example:

content_by_lua: do some subrequests. Save some timings
log_by_lua: log timings from subrequests

Is ngx.shared.dict the best option to avoid using ngx.var or ngx.ctx?

.

rkelledy

When you say it's only valid when you're making a LOT of accesses to ngx.ctx, do you mean a lot of accesses within one request, or a small amount of accesses per request but with a high request throughput?

For example:

local ctxvar = ngx.ctx.foo

ngx.say(ctxvar)

ngx.say(ngx.ctx.foo)

Is using the the variable only 2 or 3 times not worth making a local copy?

On 2 May 2016 at 12:38, Robert Paprocki <rpap...@fearnothingproductions.net> wrote:

Yep, had me worried too at first. That's why I ran some testing ;) Obviously these APIs are useful. a single call to ngx.ctx is much faster than a shared dict access. and some information from ngx.var is not available elsewhere, so it's necessary.

The point to take from the documented warnings is to avoid naively calling these API functions redundantly in a hot code path, not "don't use these functions evar!!" :p so for example, don't pass around ngx.ctx like this

=======
function foo(data, val)
data.bar = val -- this directly edits ngx.ctx
end

foo(ngx.ctx, 1)
foo(ngx.ctx, 2)
foo(ngx.ctx, 3)
=======

Instead, pass your own local data around:

=======
-- t is a local copy of ngx.ctx
local t = ngx.ctx

function foo(data, val)
data.bar = val
end

foo(t, 1) -- still passing a table to foo()
foo(t, 2)
foo(t, 3)

[...snip...]

-- save the local table back to ngx.ctx
-- do this at the end of your handler or wherever
-- you're done working with ngx.ctx
ngx.ctx = t
=======

Note the above example is only really valid when you're making a LOT of accesses to ngx.ctx, otherwise it's just harmful premature optimization ;)

On May 1, 2016, at 19:12, Rob Kelledy <rke...@gmail.com> wrote:
Hi Robert,
Thanks for your quick response. I guess this paragraph just had me worried:

"The ngx.ctx lookup requires relatively expensive metamethod calls and it is much slower than explicitly passing per-request data along by your own function arguments. So do not abuse this API for saving your own function arguments because it usually has quite some performance impact."

The same thing wasn't said for the ngx.shared.dict.

On 2 May 2016 at 11:52, Robert Paprocki <rpap...@fearnothingproductions.net> wrote:
Hey Rob,

Using these API calls is not inherently problematic, just make sure to avoid them on hit code paths. For inter-phase usage ngx.ctx is exactly what you want, the overhead of shared dicts is a waste for your use case. It's important to cache ngx.var and ngx.ctx values when accessing then multiple times in a hot code path. See https://www.cryptobells.com/properly-scoping-lua-nginx-modules-ngx-ctx/ for an emperical analysis.

On May 1, 2016, at 18:40, Rob Kay <ar...@gmail.com> wrote:

Hi,
The documentation states that ngx.var and ngx.ctx are expensive methods and should be avoided.

What is the recommended way to pass variables between Lua running in different phases. For example:

content_by_lua: do some subrequests. Save some timings
log_by_lua: log timings from subrequests

Is ngx.shared.dict the best option to avoid using ngx.var or ngx.ctx?

.

rpaprocki

Both are probably valid as "a lot", but you'd have to benchmark your specific use case to figure out what's best for your use case. If a usage pattern is good or bad in a given request context, that impact will only be exacerbated as throughput increases, so always stick to best practices (you're using Nginx so you can expect to handle tens of thousands of req/s ;) ).

I would hazard a guess that directly accessing ngx.ctx two or three times probably isn't terrible; in the paradigm of localizing -and- modifying ngx.ctx, you have a minimum of two accesses, one read and one write.

On May 1, 2016, at 19:58, Rob Kelledy <rke...@gmail.com> wrote:

When you say it's only valid when you're making a LOT of accesses to ngx.ctx, do you mean a lot of accesses within one request, or a small amount of accesses per request but with a high request throughput?

For example:

local ctxvar = ngx.ctx.foo
ngx.say(ctxvar)
ngx.say(ctxvar)

vs

ngx.say(ngx.ctx.foo)
ngx.say(ngx.ctx.foo)

Is using the the variable only 2 or 3 times not worth making a local copy?

On 2 May 2016 at 12:38, Robert Paprocki <rpap...@fearnothingproductions.net> wrote:
Yep, had me worried too at first. That's why I ran some testing ;) Obviously these APIs are useful. a single call to ngx.ctx is much faster than a shared dict access. and some information from ngx.var is not available elsewhere, so it's necessary.

The point to take from the documented warnings is to avoid naively calling these API functions redundantly in a hot code path, not "don't use these functions evar!!" :p so for example, don't pass around ngx.ctx like this

=======
function foo(data, val)
data.bar = val -- this directly edits ngx.ctx
end

foo(ngx.ctx, 1)
foo(ngx.ctx, 2)
foo(ngx.ctx, 3)
=======

Instead, pass your own local data around:

=======
-- t is a local copy of ngx.ctx
local t = ngx.ctx

function foo(data, val)
data.bar = val
end

foo(t, 1) -- still passing a table to foo()
foo(t, 2)
foo(t, 3)

[...snip...]

-- save the local table back to ngx.ctx
-- do this at the end of your handler or wherever
-- you're done working with ngx.ctx
ngx.ctx = t
=======

Note the above example is only really valid when you're making a LOT of accesses to ngx.ctx, otherwise it's just harmful premature optimization ;)

On May 1, 2016, at 19:12, Rob Kelledy <rke...@gmail.com> wrote:

Hi Robert,
Thanks for your quick response. I guess this paragraph just had me worried:

"The ngx.ctx lookup requires relatively expensive metamethod calls and it is much slower than explicitly passing per-request data along by your own function arguments. So do not abuse this API for saving your own function arguments because it usually has quite some performance impact."

The same thing wasn't said for the ngx.shared.dict.

On 2 May 2016 at 11:52, Robert Paprocki <rpap...@fearnothingproductions.net> wrote:
Hey Rob,

Using these API calls is not inherently problematic, just make sure to avoid them on hit code paths. For inter-phase usage ngx.ctx is exactly what you want, the overhead of shared dicts is a waste for your use case. It's important to cache ngx.var and ngx.ctx values when accessing then multiple times in a hot code path. See https://www.cryptobells.com/properly-scoping-lua-nginx-modules-ngx-ctx/ for an emperical analysis.

On May 1, 2016, at 18:40, Rob Kay <ar...@gmail.com> wrote:

Hi,
The documentation states that ngx.var and ngx.ctx are expensive methods and should be avoided.

What is the recommended way to pass variables between Lua running in different phases. For example:

content_by_lua: do some subrequests. Save some timings
log_by_lua: log timings from subrequests

Is ngx.shared.dict the best option to avoid using ngx.var or ngx.ctx?

.
agentzh
Hello!

On Sun, May 1, 2016 at 7:12 PM, Rob Kelledy wrote:
> "The ngx.ctx lookup requires relatively expensive metamethod calls and it is
> much slower than explicitly passing per-request data along by your own
> function arguments. So do not abuse this API for saving your own function
> arguments because it usually has quite some performance impact."
>

Don't worry too much about this paragraph. I added this note just for
people who want to achieve near-C performance with their Lua code :)

> The same thing wasn't said for the ngx.shared.dict.

This is just because people do not tend to call ngx.shared.dict as
excessively as ngx.var and ngx.ctx :)

Regards,
-agentzh