Re: [webkit-dev] Introduce WebKit Android port

[장대웅]

I agree that JSC for Android should be useful as JSC is the fastest JavaScript 
engine. 
I will try build JSCOnly for Android soon then. Thank you for your suggestion. 
:) 
 
-Original Message-
From: "Konstantin Tokarev"annu...@yandex.ru 
To: "장대웅"daewoong.j...@navercorp.com; "Michael 
Catanzaro"mcatanz...@igalia.com; 
"webkit-dev@lists.webkit.org"webkit-dev@lists.webkit.org; 
Cc: hsz...@icloud.com; "Eric Wing"ewmail...@gmail.com; 
Sent: 2017-03-18 (토) 04:23:45
Subject: Re: [webkit-dev] Introduce WebKit Android port
 


17.03.2017, 21:04, "장대웅" daewoong.j...@navercorp.com:
 Hi.

 It is not just a code drop and I will continue maintain it. Actually, I’d 
like to code
 together with anyone who is interested in it. I think WebKit is a really 
great project and
 I hope Android port make WebKit more widely used and encourage Android 
developers to contribute.

 I wrote Android port because it must be useful on Android platforms. Of 
course
 we have powerful Chromium on Android - but sometimes we need a cleaner and 
smaller
 renderer than a powerful one. I believe Android port can fit this need.

 I think it would be great if Android port is able to join upstream. I 
would appreciate
 if you let me know what is needed to upstream. Thank you for your feedback 
:)

I think you should start with upstreaming WTF and JavaScriptCore changes, 
including 
build system. There are people interested in using JSC on Android as standalone 
JavaScript
engine, I've CC'ed some of them. We have JSCOnly port intended for building JSC 
with
minimum dependencies, and it would be great if it had Android support.

As for upstreaming complete Android port, feasibility of that depends on how 
much full-time
developers are working on it, and on amount of Android-specific code. But of 
course you can
start from contributing fixes to port-independent code.


 Regards,
 Daewoong.

 -Original Message-
 From: "Michael Catanzaro"mcatanz...@igalia.com
 To: "장대웅"daewoong.j...@navercorp.com; 
webkit-dev@lists.webkit.org;
 Cc:
 Sent: 2017-03-17 (금) 11:26:19
 Subject: Re: [webkit-dev] Introduce WebKit Android port

 Hi,

 Is this just a code drop? Or will you be committing to its maintenance
 and attempting to upstream it?

 It's interesting regardless!

 Michael

 ,

 ___
 webkit-dev mailing list
 webkit-dev@lists.webkit.org
 https://lists.webkit.org/mailman/listinfo/webkit-dev


-- 
Regards,
Konstantin



___
webkit-dev mailing list
webkit-dev@lists.webkit.org
https://lists.webkit.org/mailman/listinfo/webkit-dev

Re: [webkit-dev] Proposal to limit the size of the captured exception stack

[Mark Lam]

@Geoff, my testing shows that we can do 200 frames and still perform well (~1 
second to console.log Error.stack).  Base on what we at present, I think 100 is 
a good round number to use as our default stackTraceLimit.

> On Mar 17, 2017, at 11:40 AM, Maciej Stachowiak  wrote:
> 
>> 
>> On Mar 17, 2017, at 11:09 AM, Mark Lam > > wrote:
>> 
>> Thanks for the reminder to back observations up with data.  I was previously 
>> running some tests that throws StackOverflowErrors a lot (which tainted my 
>> perspective), and I made a hasty conclusion which isn’t good.  Anyway, 
>> here’s the data using an instrumented VM to take some measurements and a 
>> simple test program that recurses forever to throw a StackOverflowError (run 
>> on a MacPro):
>> 
>> 1. For a release build of jsc shell:
>> Time to capture exception stack = 0.002807 sec
>> Number of stack frames captured = 31722
>> sizeof StackFrame = 24
>> total memory consumed = ~761328 bytes.
>> 
>> 2. For a debug build of jsc shell:
>> Time to capture exception stack = 0.052107 sec
>> Number of stack frames captured = 31688
>> sizeof StackFrame = 24
>> total memory consumed = ~760512 bytes.
>> 
>> So, regarding performance, I was wrong.  The amount of time taken to capture 
>> the entire JS stack each time is insignificant.
>> Regarding memory usage, ~760K is not so good, but maybe it’s acceptable.
>> 
>> Comparing browsers with their respective inspectors open:
>> 
>> 1. Chrome
>> number of frames captured: 10
>> length of e.stack string: 824 chars
>> time to console.log e.stack: 0.27 seconds
>> 
>> 2. Firefox
>> number of frames captured: 129
>> length of e.stack string: 8831 chars
>> time to console.log e.stack: 0.93 seconds
>> 
>> 3. Safari
>> number of frames captured: 31722
>> length of e.stack string: 218821 chars
>> time to console.log e.stack: 50.8 seconds
>> 
>> 4. Safari (with error.stack shrunk to 201 frames at time of capture to 
>> simulate my proposal)
>> number of frames captured: 201
>> length of e.stack string: 13868 chars
>> time to console.log e.stack: 1 second
>> 
>> With my proposal, the experience of printing Error.stack drops from 50.8 
>> seconds to about 1 second.  The memory used for capturing the stack also 
>> drops from ~760K to 5K.
>> 
>> I wasn’t aware of the Error.stackTraceLimit, but that does sound like a 
>> better solution than my proposal since it gives developers the ability to 
>> capture more stack frames if they need it.  Chrome’s default 
>> Error.stackTraceLimit appears to be 10.  MS appears to support it as well 
>> and defaults to 10 
>> (https://docs.microsoft.com/en-us/scripting/javascript/reference/stacktracelimit-property-error-javascript
>>  
>> ).
>>   Firefox does now.
> 
> Out of curiosity: Why does Firefox capture 129 frames instead of 31722 in 
> this case? Do they have a hardcoded limit?

Actually, my previous frame counts are a bit off.  I was using 
e.stack.split(/\r\n|\r|\n/).length as the frame count.  Below, I just copy the 
console.log dump into an editor and take the line count from there as the frame 
count instead.  The result of that string.split appears to be a bit off from 
the actual frames printed by console.log. 

I also modified my recursing test function to console.log the re-entry count on 
entry and this is what I saw:

1. Chrome
test reported reentry count = 10150
split(…).length = 11 (because Chromes starts e.stack with a line 
"RangeError: Maximum call stack size exceeded”)
e.stack lines according to editor = 10 frames

2. Firefox
test reported reentry count = 222044
split(…).length = 129 (probably because there’s an extra newline in 
there somewhere)
e.stack lines according to editor = 128 frames

3. Safari
test reported reentry count = 31701
split(…).length = 31722 (I don’t know why there’s a 21 frame 
discrepancy here.  I’ll debug this later)
e.stack lines according to editor = ??? frames (WebInspector hangs every 
time I try to scroll in it, let alone let me highlight and copy the stack 
trace.  So I gave up)

Assuming the test function frame is not significantly different in size for all 
browsers, it looks like:
1. Chrome uses a much smaller stack (about 1/3 of our stack).
2. Firefox uses a much larger stack (possibly the full machine stack), but caps 
its Error.stack to just 128 frames (possibly a hardcoded limit).

Mark


> 
>  - Maciej
> 
>> 
>> Does anyone object to us adopting Error.stackTraceLimit and setting the 
>> default to 10 to match Chrome?
>> 
>> Mark
>> 
>> 
>> 
>>> On Mar 16, 2017, at 11:29 PM, Geoffrey Garen >> > wrote:
>>> 
>>> Can you be more specific about the motivation here?
>>> 
>>> Do we have any motivating 

Re: [webkit-dev] Introduce WebKit Android port

[Konstantin Tokarev]

17.03.2017, 21:04, "장대웅" :
> Hi.
>
> It is not just a code drop and I will continue maintain it. Actually, I’d 
> like to code
> together with anyone who is interested in it. I think WebKit is a really 
> great project and
> I hope Android port make WebKit more widely used and encourage Android 
> developers to contribute.
>
> I wrote Android port because it must be useful on Android platforms. Of course
> we have powerful Chromium on Android - but sometimes we need a cleaner and 
> smaller
> renderer than a powerful one. I believe Android port can fit this need.
>
> I think it would be great if Android port is able to join upstream. I would 
> appreciate
> if you let me know what is needed to upstream. Thank you for your feedback :)

I think you should start with upstreaming WTF and JavaScriptCore changes, 
including 
build system. There are people interested in using JSC on Android as standalone 
JavaScript
engine, I've CC'ed some of them. We have JSCOnly port intended for building JSC 
with
minimum dependencies, and it would be great if it had Android support.

As for upstreaming complete Android port, feasibility of that depends on how 
much full-time
developers are working on it, and on amount of Android-specific code. But of 
course you can
start from contributing fixes to port-independent code.

>
> Regards,
> Daewoong.
>
> -Original Message-
> From: "Michael Catanzaro"
> To: "장대웅"; ;
> Cc:
> Sent: 2017-03-17 (금) 11:26:19
> Subject: Re: [webkit-dev] Introduce WebKit Android port
>
> Hi,
>
> Is this just a code drop? Or will you be committing to its maintenance
> and attempting to upstream it?
>
> It's interesting regardless!
>
> Michael
>
> ,
>
> ___
> webkit-dev mailing list
> webkit-dev@lists.webkit.org
> https://lists.webkit.org/mailman/listinfo/webkit-dev


-- 
Regards,
Konstantin
___
webkit-dev mailing list
webkit-dev@lists.webkit.org
https://lists.webkit.org/mailman/listinfo/webkit-dev

Re: [webkit-dev] Proposal to limit the size of the captured exception stack

[Maciej Stachowiak]

> On Mar 17, 2017, at 11:09 AM, Mark Lam  wrote:
> 
> Thanks for the reminder to back observations up with data.  I was previously 
> running some tests that throws StackOverflowErrors a lot (which tainted my 
> perspective), and I made a hasty conclusion which isn’t good.  Anyway, here’s 
> the data using an instrumented VM to take some measurements and a simple test 
> program that recurses forever to throw a StackOverflowError (run on a MacPro):
> 
> 1. For a release build of jsc shell:
> Time to capture exception stack = 0.002807 sec
> Number of stack frames captured = 31722
> sizeof StackFrame = 24
> total memory consumed = ~761328 bytes.
> 
> 2. For a debug build of jsc shell:
> Time to capture exception stack = 0.052107 sec
> Number of stack frames captured = 31688
> sizeof StackFrame = 24
> total memory consumed = ~760512 bytes.
> 
> So, regarding performance, I was wrong.  The amount of time taken to capture 
> the entire JS stack each time is insignificant.
> Regarding memory usage, ~760K is not so good, but maybe it’s acceptable.
> 
> Comparing browsers with their respective inspectors open:
> 
> 1. Chrome
> number of frames captured: 10
> length of e.stack string: 824 chars
> time to console.log e.stack: 0.27 seconds
> 
> 2. Firefox
> number of frames captured: 129
> length of e.stack string: 8831 chars
> time to console.log e.stack: 0.93 seconds
> 
> 3. Safari
> number of frames captured: 31722
> length of e.stack string: 218821 chars
> time to console.log e.stack: 50.8 seconds
> 
> 4. Safari (with error.stack shrunk to 201 frames at time of capture to 
> simulate my proposal)
> number of frames captured: 201
> length of e.stack string: 13868 chars
> time to console.log e.stack: 1 second
> 
> With my proposal, the experience of printing Error.stack drops from 50.8 
> seconds to about 1 second.  The memory used for capturing the stack also 
> drops from ~760K to 5K.
> 
> I wasn’t aware of the Error.stackTraceLimit, but that does sound like a 
> better solution than my proposal since it gives developers the ability to 
> capture more stack frames if they need it.  Chrome’s default 
> Error.stackTraceLimit appears to be 10.  MS appears to support it as well and 
> defaults to 10 
> (https://docs.microsoft.com/en-us/scripting/javascript/reference/stacktracelimit-property-error-javascript
>  
> ).
>   Firefox does now.

Out of curiosity: Why does Firefox capture 129 frames instead of 31722 in this 
case? Do they have a hardcoded limit?

 - Maciej

> 
> Does anyone object to us adopting Error.stackTraceLimit and setting the 
> default to 10 to match Chrome?
> 
> Mark
> 
> 
> 
>> On Mar 16, 2017, at 11:29 PM, Geoffrey Garen > > wrote:
>> 
>> Can you be more specific about the motivation here?
>> 
>> Do we have any motivating examples that will tell us wether time+memory were 
>> unacceptable before this change, or are acceptable after this change?
>> 
>> In our motivating examples, does Safari use more time+memory than other 
>> browsers? If so, how large of a stack do other browsers capture?
>> 
>> We already limit the size of the JavaScript stack to avoid performance 
>> problems like the ones you mention in many other contexts. Why is that limit 
>> not sufficient?
>> 
>> Did you consider implementing Chrome’s Error.stackTraceLimit behavior?
>> 
>> Geoff
>> 
>>> On Mar 16, 2017, at 10:09 PM, Mark Lam >> > wrote:
>>> 
>>> Hi folks,
>>> 
>>> Currently, if we have an exception stack that is incredibly deep 
>>> (especially for a StackOverflowError), JSC may end up thrashing memory just 
>>> to capture the large stack trace in memory.This is bad for many reasons:
>>> 
>>> 1. the captured stack will take a lot of memory.
>>> 2. capturing the stack may take a long time (due to memory thrashing) and 
>>> makes for a bad user experience.
>>> 3. if memory availability is low, capturing such a large stack may result 
>>> in an OutOfMemoryError being thrown in its place.
>>>   The OutOfMemoryError thrown there will also have the same problem with 
>>> capturing such a large stack.
>>> 4. most of the time, no one will look at the captured Error.stack anyway.
>>> 
>>> Since there isn’t a standard on what we really need to capture for 
>>> Error.stack, I propose that we limit how much stack we capture to a 
>>> practical size.  How about an Error.stack that consists of (1) the top N 
>>> frames, (2) an ellipses, and (3) the bottom M frames?  If the number of 
>>> frames on the stack at the time of capture  is less or equal to than N + M 
>>> frames, then Error.stack will just show the whole stack with no ellipses.  
>>> For example, if N is 4 and M is 2, the captured stack will look something 
>>> like this:

Re: [webkit-dev] Proposal to limit the size of the captured exception stack

[Geoffrey Garen]

Thanks for the detailed write-up.

The main thing that sticks out to me in this data is that Safari defaults to 
capturing a stack that is, in the worst case, roughly 3000X larger than the 
stack in IE and Chrome. That’s a big difference. I think this could be a real 
website compatibility problem since an author who tested in IE or Chrome might 
not notice a repeatedly thrown exception, which could cause time or memory or 
even bandwidth problems (if the author phoned home with exception data) in 
Safari.

Since Chrome and IE have already adopted it, I like Error.stackTraceLimit, and 
I think we should propose standardizing it. (We can standardize 
Error.stackTraceLimit even before we fully standardize the text content of 
Error.stack.)

I think 10 is possibly an unnecessarily low default. Most stack traces are 
bigger than 10. 30 would still be two orders of magnitude better than the 
status quo. Even 50 or 100 might be OK, as long as your testing shows it’s not 
too expensive.

Elipsizing was a cool idea, but given the behavior of other browsers, I think 
it’s better to truncate Error.stack and consider elipsizing in Web Inspector, 
where presentation matters more and has less of an effect on web compatibility.

Geoff

> On Mar 17, 2017, at 11:09 AM, Mark Lam  wrote:
> 
> Thanks for the reminder to back observations up with data.  I was previously 
> running some tests that throws StackOverflowErrors a lot (which tainted my 
> perspective), and I made a hasty conclusion which isn’t good.  Anyway, here’s 
> the data using an instrumented VM to take some measurements and a simple test 
> program that recurses forever to throw a StackOverflowError (run on a MacPro):
> 
> 1. For a release build of jsc shell:
> Time to capture exception stack = 0.002807 sec
> Number of stack frames captured = 31722
> sizeof StackFrame = 24
> total memory consumed = ~761328 bytes.
> 
> 2. For a debug build of jsc shell:
> Time to capture exception stack = 0.052107 sec
> Number of stack frames captured = 31688
> sizeof StackFrame = 24
> total memory consumed = ~760512 bytes.
> 
> So, regarding performance, I was wrong.  The amount of time taken to capture 
> the entire JS stack each time is insignificant.
> Regarding memory usage, ~760K is not so good, but maybe it’s acceptable.
> 
> Comparing browsers with their respective inspectors open:
> 
> 1. Chrome
> number of frames captured: 10
> length of e.stack string: 824 chars
> time to console.log e.stack: 0.27 seconds
> 
> 2. Firefox
> number of frames captured: 129
> length of e.stack string: 8831 chars
> time to console.log e.stack: 0.93 seconds
> 
> 3. Safari
> number of frames captured: 31722
> length of e.stack string: 218821 chars
> time to console.log e.stack: 50.8 seconds
> 
> 4. Safari (with error.stack shrunk to 201 frames at time of capture to 
> simulate my proposal)
> number of frames captured: 201
> length of e.stack string: 13868 chars
> time to console.log e.stack: 1 second
> 
> With my proposal, the experience of printing Error.stack drops from 50.8 
> seconds to about 1 second.  The memory used for capturing the stack also 
> drops from ~760K to 5K.
> 
> I wasn’t aware of the Error.stackTraceLimit, but that does sound like a 
> better solution than my proposal since it gives developers the ability to 
> capture more stack frames if they need it.  Chrome’s default 
> Error.stackTraceLimit appears to be 10.  MS appears to support it as well and 
> defaults to 10 
> (https://docs.microsoft.com/en-us/scripting/javascript/reference/stacktracelimit-property-error-javascript
>  
> ).
>   Firefox does now.
> 
> Does anyone object to us adopting Error.stackTraceLimit and setting the 
> default to 10 to match Chrome?
> 
> Mark
> 
> 
> 
>> On Mar 16, 2017, at 11:29 PM, Geoffrey Garen > > wrote:
>> 
>> Can you be more specific about the motivation here?
>> 
>> Do we have any motivating examples that will tell us wether time+memory were 
>> unacceptable before this change, or are acceptable after this change?
>> 
>> In our motivating examples, does Safari use more time+memory than other 
>> browsers? If so, how large of a stack do other browsers capture?
>> 
>> We already limit the size of the JavaScript stack to avoid performance 
>> problems like the ones you mention in many other contexts. Why is that limit 
>> not sufficient?
>> 
>> Did you consider implementing Chrome’s Error.stackTraceLimit behavior?
>> 
>> Geoff
>> 
>>> On Mar 16, 2017, at 10:09 PM, Mark Lam >> > wrote:
>>> 
>>> Hi folks,
>>> 
>>> Currently, if we have an exception stack that is incredibly deep 
>>> (especially for a StackOverflowError), JSC may end up thrashing memory just 
>>> to capture the large 

Re: [webkit-dev] Proposal to limit the size of the captured exception stack

[Mark Lam]

Thanks for the reminder to back observations up with data.  I was previously 
running some tests that throws StackOverflowErrors a lot (which tainted my 
perspective), and I made a hasty conclusion which isn’t good.  Anyway, here’s 
the data using an instrumented VM to take some measurements and a simple test 
program that recurses forever to throw a StackOverflowError (run on a MacPro):

1. For a release build of jsc shell:
Time to capture exception stack = 0.002807 sec
Number of stack frames captured = 31722
sizeof StackFrame = 24
total memory consumed = ~761328 bytes.

2. For a debug build of jsc shell:
Time to capture exception stack = 0.052107 sec
Number of stack frames captured = 31688
sizeof StackFrame = 24
total memory consumed = ~760512 bytes.

So, regarding performance, I was wrong.  The amount of time taken to capture 
the entire JS stack each time is insignificant.
Regarding memory usage, ~760K is not so good, but maybe it’s acceptable.

Comparing browsers with their respective inspectors open:

1. Chrome
number of frames captured: 10
length of e.stack string: 824 chars
time to console.log e.stack: 0.27 seconds

2. Firefox
number of frames captured: 129
length of e.stack string: 8831 chars
time to console.log e.stack: 0.93 seconds

3. Safari
number of frames captured: 31722
length of e.stack string: 218821 chars
time to console.log e.stack: 50.8 seconds

4. Safari (with error.stack shrunk to 201 frames at time of capture to simulate 
my proposal)
number of frames captured: 201
length of e.stack string: 13868 chars
time to console.log e.stack: 1 second

With my proposal, the experience of printing Error.stack drops from 50.8 
seconds to about 1 second.  The memory used for capturing the stack also drops 
from ~760K to 5K.

I wasn’t aware of the Error.stackTraceLimit, but that does sound like a better 
solution than my proposal since it gives developers the ability to capture more 
stack frames if they need it.  Chrome’s default Error.stackTraceLimit appears 
to be 10.  MS appears to support it as well and defaults to 10 
(https://docs.microsoft.com/en-us/scripting/javascript/reference/stacktracelimit-property-error-javascript
 
).
  Firefox does now.

Does anyone object to us adopting Error.stackTraceLimit and setting the default 
to 10 to match Chrome?

Mark



> On Mar 16, 2017, at 11:29 PM, Geoffrey Garen  wrote:
> 
> Can you be more specific about the motivation here?
> 
> Do we have any motivating examples that will tell us wether time+memory were 
> unacceptable before this change, or are acceptable after this change?
> 
> In our motivating examples, does Safari use more time+memory than other 
> browsers? If so, how large of a stack do other browsers capture?
> 
> We already limit the size of the JavaScript stack to avoid performance 
> problems like the ones you mention in many other contexts. Why is that limit 
> not sufficient?
> 
> Did you consider implementing Chrome’s Error.stackTraceLimit behavior?
> 
> Geoff
> 
>> On Mar 16, 2017, at 10:09 PM, Mark Lam  wrote:
>> 
>> Hi folks,
>> 
>> Currently, if we have an exception stack that is incredibly deep (especially 
>> for a StackOverflowError), JSC may end up thrashing memory just to capture 
>> the large stack trace in memory.This is bad for many reasons:
>> 
>> 1. the captured stack will take a lot of memory.
>> 2. capturing the stack may take a long time (due to memory thrashing) and 
>> makes for a bad user experience.
>> 3. if memory availability is low, capturing such a large stack may result in 
>> an OutOfMemoryError being thrown in its place.
>>   The OutOfMemoryError thrown there will also have the same problem with 
>> capturing such a large stack.
>> 4. most of the time, no one will look at the captured Error.stack anyway.
>> 
>> Since there isn’t a standard on what we really need to capture for 
>> Error.stack, I propose that we limit how much stack we capture to a 
>> practical size.  How about an Error.stack that consists of (1) the top N 
>> frames, (2) an ellipses, and (3) the bottom M frames?  If the number of 
>> frames on the stack at the time of capture  is less or equal to than N + M 
>> frames, then Error.stack will just show the whole stack with no ellipses.  
>> For example, if N is 4 and M is 2, the captured stack will look something 
>> like this:
>> 
>> foo10001
>> foo1
>> foo
>> foo9998
>> …
>> foo1
>> foo0
>> 
>> If we pick a sufficient large number for N and M (I suggest 100 each), I 
>> think this should provide sufficient context for debugging uses of 
>> Error.stack, while keeping an upper bound on how much memory and time we 
>> throw at capturing the exception stack.
>> 
>> My plan for implementing this is:
>> 1. change 

Re: [webkit-dev] Introduce WebKit Android port

[장대웅]

Hi.

It is not just a code drop and I will continue maintain it. Actually, I’d like 
to code
together with anyone who is interested in it. I think WebKit is a really great 
project and
I hope Android port make WebKit more widely used and encourage Android 
developers to contribute.

I wrote Android port because it must be useful on Android platforms. Of course 
we have powerful Chromium on Android - but sometimes we need a cleaner and 
smaller 
renderer than a powerful one. I believe Android port can fit this need.

I think it would be great if Android port is able to join upstream. I would 
appreciate
if you let me know what is needed to upstream. Thank you for your feedback :)

Regards,
Daewoong.
 
 
-Original Message-
From: "Michael Catanzaro"mcatanz...@igalia.com 
To: "장대웅"daewoong.j...@navercorp.com; 
webkit-dev@lists.webkit.org; 
Cc: 
Sent: 2017-03-17 (금) 11:26:19
Subject: Re: [webkit-dev] Introduce WebKit Android port
 
Hi,

Is this just a code drop? Or will you be committing to its maintenance
and attempting to upstream it?

It's interesting regardless!

Michael



___
webkit-dev mailing list
webkit-dev@lists.webkit.org
https://lists.webkit.org/mailman/listinfo/webkit-dev

Re: [webkit-dev] svn.webkit.org, git.webkit.org, trac.webkit.org and perf.webkit.org transition today on Friday at 10am PDT

[Ling Ho]

We are postponing the changes to mid next week because of blocking task 
not able to complete in time. Apologies for any disruption this may have 
caused.


...
ling

On 3/16/17 5:34 PM, Ling Ho wrote:

Hello WebKit developers,

We have rescheduled our switch of svn.webkit.org and git.webkit.org 
for Friday (3/17) morning, between 10 and 11am PDT. We will also be 
moving trac.webkit.org and perf.webkit.org during the same time.


The current svn repository will be made read-only at 10am. We will 
send out a notice when commit can be made again.


Thanks,
...
ling

On 3/13/17 3:02 PM, Lucas Forschler wrote:

Hello WebKit,

Both svn.webkit.org  and the git.webkit.org 
 mirror will be transitioning to new hardware 
this evening.


For svn.webkit.org , our plan is to make the 
current repository read only between 6:00 and 6:30. As soon as the 
DNS change takes effect, you should be able to commit to the new 
server as expected, with no changes. We are using the same UUID and 
SSL certificate, so your source checkout should not complain. I’ll 
follow-up with another reminder shortly before we make any changes.


Thanks,
Lucas



___
webkit-dev mailing list
webkit-dev@lists.webkit.org
https://lists.webkit.org/mailman/listinfo/webkit-dev




___
webkit-dev mailing list
webkit-dev@lists.webkit.org
https://lists.webkit.org/mailman/listinfo/webkit-dev


___
webkit-dev mailing list
webkit-dev@lists.webkit.org
https://lists.webkit.org/mailman/listinfo/webkit-dev

Re: [webkit-dev] build.webkit.org transition today at 3pm PDT

[Lucas Forschler]

Hi Carlos,

The results folder is being copied over, it’s just taking a long time since 
it’s many TB of data.

Interesting on the build counter being reset to zero… that is unexpected. I 
will investigate. Thanks for pointing it out!

Lucas


> On Mar 17, 2017, at 5:09 AM, Carlos Alberto Lopez Perez  
> wrote:
> 
> On 16/03/17 22:40, Ling Ho wrote:
>> Hello WebKit developers:
>> 
>> We are continuing our transitioning of webkit.org servers today and
>> tomorrow. Between 3pm and 4pm Pacific, we will be moving
>> build.webkit.org. Please email us at ad...@webkit.org if you encounter
>> any issue with your build bots after the transition.
>> 
>> Thanks,
>> ...
>> ling
>> ___
>> webkit-dev mailing list
>> webkit-dev@lists.webkit.org
>> https://lists.webkit.org/mailman/listinfo/webkit-dev
>> 
> 
> It looks the buildbot database was wiped during the migration? :(
> 
> The counter number for the builds has been reset to 0 and all previous
> information about layout test results at
> https://build.webkit.org/results/ has been lost.
> 
> 
> This information was used by several tools like the flakiness dashboard
> the TestFailures tool, wktesthunter [1], and maybe other tools.
> 
> 
> I wonder if the files from the results/ directory of the old server can
> be recovered and copied to the results/ directory of this new one?.
> Or at least make that available for download as a tarball ?
> 
> 
> 
> [1] https://github.com/clopez/webkit-testhunter
> 

___
webkit-dev mailing list
webkit-dev@lists.webkit.org
https://lists.webkit.org/mailman/listinfo/webkit-dev

Re: [webkit-dev] build.webkit.org transition today at 3pm PDT

[Carlos Alberto Lopez Perez]

On 16/03/17 22:40, Ling Ho wrote:
> Hello WebKit developers:
> 
> We are continuing our transitioning of webkit.org servers today and
> tomorrow. Between 3pm and 4pm Pacific, we will be moving
> build.webkit.org. Please email us at ad...@webkit.org if you encounter
> any issue with your build bots after the transition.
> 
> Thanks,
> ...
> ling
> ___
> webkit-dev mailing list
> webkit-dev@lists.webkit.org
> https://lists.webkit.org/mailman/listinfo/webkit-dev
> 

It looks the buildbot database was wiped during the migration? :(

The counter number for the builds has been reset to 0 and all previous
information about layout test results at
https://build.webkit.org/results/ has been lost.


This information was used by several tools like the flakiness dashboard
the TestFailures tool, wktesthunter [1], and maybe other tools.


I wonder if the files from the results/ directory of the old server can
be recovered and copied to the results/ directory of this new one?.
Or at least make that available for download as a tarball ?



[1] https://github.com/clopez/webkit-testhunter



signature.asc
Description: OpenPGP digital signature
___
webkit-dev mailing list
webkit-dev@lists.webkit.org
https://lists.webkit.org/mailman/listinfo/webkit-dev

Re: [webkit-dev] Proposal to limit the size of the captured exception stack

[Geoffrey Garen]

Can you be more specific about the motivation here?

Do we have any motivating examples that will tell us wether time+memory were 
unacceptable before this change, or are acceptable after this change?

In our motivating examples, does Safari use more time+memory than other 
browsers? If so, how large of a stack do other browsers capture?

We already limit the size of the JavaScript stack to avoid performance problems 
like the ones you mention in many other contexts. Why is that limit not 
sufficient?

Did you consider implementing Chrome’s Error.stackTraceLimit behavior?

Geoff

> On Mar 16, 2017, at 10:09 PM, Mark Lam  wrote:
> 
> Hi folks,
> 
> Currently, if we have an exception stack that is incredibly deep (especially 
> for a StackOverflowError), JSC may end up thrashing memory just to capture 
> the large stack trace in memory.This is bad for many reasons:
> 
> 1. the captured stack will take a lot of memory.
> 2. capturing the stack may take a long time (due to memory thrashing) and 
> makes for a bad user experience.
> 3. if memory availability is low, capturing such a large stack may result in 
> an OutOfMemoryError being thrown in its place.
>The OutOfMemoryError thrown there will also have the same problem with 
> capturing such a large stack.
> 4. most of the time, no one will look at the captured Error.stack anyway.
> 
> Since there isn’t a standard on what we really need to capture for 
> Error.stack, I propose that we limit how much stack we capture to a practical 
> size.  How about an Error.stack that consists of (1) the top N frames, (2) an 
> ellipses, and (3) the bottom M frames?  If the number of frames on the stack 
> at the time of capture  is less or equal to than N + M frames, then 
> Error.stack will just show the whole stack with no ellipses.  For example, if 
> N is 4 and M is 2, the captured stack will look something like this:
> 
>  foo10001
>  foo1
>  foo
>  foo9998
>  …
>  foo1
>  foo0
> 
> If we pick a sufficient large number for N and M (I suggest 100 each), I 
> think this should provide sufficient context for debugging uses of 
> Error.stack, while keeping an upper bound on how much memory and time we 
> throw at capturing the exception stack.
> 
> My plan for implementing this is:
> 1. change Exception::finishCreation() to only capture the N and M frames, 
> plus possibly 1 ellipses placeholder in the between them.
> 2. change all clients of Exception::stack() to be able to recognize and 
> render the ellipses.
> 
> Does anyone object to doing this or have a compelling reason why this should 
> not be done?
> 
> Thanks.
> 
> Mark
> 
> 
> 
> ___
> webkit-dev mailing list
> webkit-dev@lists.webkit.org
> https://lists.webkit.org/mailman/listinfo/webkit-dev

___
webkit-dev mailing list
webkit-dev@lists.webkit.org
https://lists.webkit.org/mailman/listinfo/webkit-dev