Hi I have a Windows phone app which is getting a number of crashes reported by the dev center.
I recently did an upgrade which included some minor changes and the moving of some common code from a Silverlight class library to a Windows phone class library (so that I could open the project in VS2013).
No issues in all my testing in the emulator and on the phone.
A fair number of the crashes seem to be in the background agent generating a tile.. not obvious why but I can at least see which method in my code (not sure how to use the offet to find the exact line.
However the bulk of me errors are error E06D7363 errors with the following stack trace. (have to reduce as ist too big to include fully)
Nothing in here that remotely looks like my code so I have no idea where to start.
Any ideas to pint me in the right direction?
thanks.
Frame Image Function Offset
0 headlesshost __ImageBase 0x00000007
1 coreclr CLRException::HandlerState::SetupCatch 0x00000075
2 coreclr Module::DoInit 0x00000275
3 msvcrt __CxxCallCatchBlock 0x00000077
4 msvcrt _getpid 0x00000608
5 coreclr __dyn_tls_init_callback _PERF_ 0x00000000
6 coreclr CAssemblyLocation::`vftable' 0x0007aa44
7 coreclr CAssemblyLocation::`vftable' 0x0007aa1c
8 coreclr Module::DoInit 0x00000133
9 coreclr Module::DoInit 0x00000001
10 msvcrt __piob _PERF_ 0x00000000
11 ntdll __PchSym_ _PERF_ 0x00000000
12 coreclr SString::ConvertToUnicode 0x0000002d
13 coreclr Module::DoInit 0x00000131
14 msvcrt _CallSettingFrame 0x00000011
15 msvcrt __CxxCallCatchBlock 0x000000b1
16 ntdll RcConsolidateFrames 0x00000005
17 ntdll RtlUnwindEx 0x000001d3
18 coreclr operator new 0x00000011
19 coreclr PEImage::s_hashLock 0x00000000
20 coreclr PEImage::Release 0x00000091
21 coreclr BINDER_SPACE::AssemblyBinder::BindToSystemSatellite 0x000000d1
22 ntdll RtlUnwindEx 0x00000001
23 msvcrt _UnwindNestedFrames 0x00000069
24 msvcrt __CxxCallCatchBlock 0x00000001
25 coreclr CAssemblyLocation::`vftable' 0x0007aa30
26 coreclr CAssemblyLocation::`vftable' 0x0007aa08
27 msvcrt FindHandler 0x0000026f
28 coreclr Module::DoInit 0x0000011b
29 coreclr CTA2PAVException 0x00000008
30 msvcrt _getptd_noexit 0x0000001b
31 msvcrt __InternalCxxFrameHandler 0x00000155
32 msvcrt __CxxFrameHandler3 0x00000043
33 coreclr CAssemblyLocation::`vftable' 0x0007ab00
34 ntdll RtlpExecuteHandlerForException 0x00000009
35 ntdll RtlDispatchException 0x0000015d
36 coreclr _CxxFrameHandler3 0x00000001
37 coreclr ExceptionHijack_xdata_end 0x0001b3ec
38 coreclr LoaderHeap::RealAllocMemUnsafe 0x00000001
39 kernelbase __ImageBase 0x00000000
40 kernelbase __PchSym_ _PERF_ 0x00000000
41 msvcrt __sbh_initialized 0x00000000
42 msvcrt __piob _PERF_ 0x00000000
43 coreclr __dyn_tls_init_callback _PERF_ 0x00000000
44 coreclr __dyn_tls_init_callback _PERF_ 0x00000000
45 coreclr __dyn_tls_init_callback _PERF_ 0x00000000
46 coreclr __dyn_tls_init_callback _PERF_ 0x00000000
47 coreclr __dyn_tls_init_callback _PERF_ 0x00000000
48 sechost lsalook__MIDL_TypeFormatString 0x000001e2
49 rpcrt4 NdrConformantVaryingArrayUnmarshall 0x00000045
<output removed here >
96 coreclr BaseAssemblySpec::CloneFields 0x00000047
97 coreclr __ClrAllocInProcessHeap 0x00000000
98 coreclr EEHeapAllocInProcessHeap
In your case finding the Solution would be needed lots of surfing through sites and Search for the Description of Error codes and find solution for it or You can simply Analyze crash reports. you’ll receive a certification report that contains additional files that you can use to identify what happened. Depending on the type of error that occurred, you’ll receive either A crash dump file or An ErrorInfo file. To examine these files, Dev centre recommend that you use either Microsoft Visual Studio or the Windows Debugger Tools. Have Look over here Analyzing crash reports and Improving apps with Quality reports. Hope this help you out.
Related
I'm in the process of writing some N-body simulation code with short-ranged interactions in CUDA targeted toward Volta and Turing series cards. I plan on using shared memory, but it's not quite clear to me how to avoid bank conflicts when doing so. Since my interactions are local, I was planning on sorting my particle data into local groups that I can send to each SM's shared memory (not yet worrying about particles that have a neighbor who is being worked on from another SM. In order to get good performance (avoid bank conflicts), is it sufficient only that each thread reads/writes from/to a different address of shared memory, but each thread may access that memory non-sequentially without penalty?
All of the information I see seems to only mention that memory be coalesced for the copy from global memory to shared memory, but don't I see anything about whether threads in a warp (or the whole SM) care about coalesence in shared memory.
In order to get good performance (avoid bank conflicts), is it sufficient only that each thread reads/writes from/to a different address of shared memory, but each thread may access that memory non-sequentially without penalty?
bank conflicts are only possible between threads in a single warp that are performing a shared memory access, and then only possible on a per-instruction (issued) basis. The instructions I am talking about here are SASS (GPU assembly code) instructions, but nevertheless should be directly identifiable from shared memory references in CUDA C++ source code.
There is no such idea as bank conflicts:
between threads in different warps
between shared memory accesses arising from different (issued) instructions
A given thread may access shared memory in any pattern, with no concern or possibility of shared memory back conflicts, due to its own activity. Bank conflicts only arise as a result of 2 or more threads in a single warp, as a result of a particular shared memory instruction or access, issued warp-wide.
Furthermore it is not sufficient that each thread reads/writes from/to a different address. For a given issued instruction (i.e. a given access) roughly speaking, each thread in the warp must read from a different bank, or else it must read from an address that is the same as another address in the warp (broadcast).
Let's assume that we are referring to 32-bit banks, and an arrangement of 32 banks.
Shared memory can readily be imagined as a 2D arrangement:
Addr Bank
v 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
0 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
32 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
64 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
96 96 97 98 ...
We see that addresses/index/offset/locations 0, 32, 64, 96 etc. are in the same bank. Addresses 1, 33, 65, 97, etc. are in the same bank, and so on, for each of the 32 banks. Banks are like columns of locations when the addresses of shared memory are visualized in this 2D arrangement
The requirement for non-bank-conflicted access for a given instruction (load or store) issued to a warp is:
no 2 threads in the warp may access locations in the same bank/column.
a special case exists if the locations in the same column are actually the same location. This invokes the broadcast rule and does not lead to bank conflicts.
And to repeat some statements above in a slightly different way:
If I have a loop in CUDA code, there is no possibility for bank conflicts to arise between separate iterations of that loop
If I have two separate lines of CUDA C++ code, there is no possibility for bank conflicts to arise between those two separate lines of CUDA C++ code.
Have tried some of the online references as wells as unix time form at etc. but none of these seem to work. See the examples below.
running Mysql 5.5.5 in ubuntu. innodb engine.
nothing is custom. This is using a built in datetime function.
Here are some examples with the 6 byte hex string and the decoded message below. We are looking for the decoding algorithm. i.e.how to turn the 6 byte hex string into the correct date/time. The algorithm must work correctly on the examples below. The right most byte seems to indicate difference in seconds correctly for small small differences in time between records. i.e. we show an example with 14 sec difference.
full records,nicely highlighted and formated word doc here.
https://www.dropbox.com/s/zsqy9o2rw1h0e09/mysql%20datetime%20examples%20.docx?dl=0
link to formatted word document with the examples.
contact frank%simrex.com re. reward.
replace % with #
hex strings and decoded date/time pairs are below.
pulled from healthy file running mysql
12 51 72 78 B9 46 ... 2014-10-22 16:53:18
12 51 72 78 B9 54 ... 2014-10-22 16:53:32
12 51 72 78 BA 13 ... 2014-10-22 16:55:23
12 51 72 78 CC 27 ... 2014-10-22 17:01:51
here you go.
select str_to_date(conv(replace('12 51 72 78 CC 27',' ', ''), 16, 10), '%Y%m%d%H%i%s')
I am working in VB 2010 to create some data acquisition programs and one of the requests is that we use Google Drive to store and share the Excel files once created. I have been able to save and sync folders into My Drive, I now need to be able to share this folder with a variable list of email addresses.
The emails would all be "name"#mix.wvu.edu and they would be inputing those at the beginning of the experiment so that when they save it will automatically be sent to My Drive and then emailed to the students.
Basically, I need some help writing code to select a folder of files from My Drive, click "share", add people that have the ability to edit the files and send them upon the student clicking the button below. Any help would be much appreciated! Thank you!
sample code of what I have so far as a .xlsx file
Sample data set
Tension Test
Date: Apr-06-2013 Load Extension Stress Strain
Time: 15:07 6 4.5
Specimen Material: Plexiglass 7 6
Specimen #: 14 8 7.5
Width: 34 9 9
Thickness: 3 10 10.5
Area: 102 11 12
Gage Length: 3 12 13.5
Data Rate: 10 13 15
14 16.5
15 18
16 19.5
17 21
18 22.5
19 24
20 25.5
21 27
22 28.5
23 30
24 31.5
25 33
For sharing files, please see: https://developers.google.com/drive/manage-sharing and the permissions resource: https://developers.google.com/drive/v2/reference/permissions
If you have any specific questions, please ask them.
I need to extract this specific JSON-field into a parameter for my performance test in Visual Studio:
"ExamAnswerId": "757a3735-e626-412b-934c-e577c6963d51"
the problem occurs when I try to do this manually by right clicking the response and click "add extraction rule". The text is split up into 3 different rows with lots of unreadable numbers next to it like this:
"0x00000000 7B 22 45 78 61 6D 41 6E 73 77 65 72 49 64 22 3A {"ExamAnswerId":
0x00000010 22 37 35 37 61 33 37 33 35 2D 65 36 32 36 2D 34 "757a3735-e626-4
This will sound dumb, but I somehow need to extract 3 different parameters, only because I can't copy/paste it -- and this is also where I think I fail.
the ExamAnswerId is important for me to fullfill another webrequest later on, but I can't seem to pass it on properly.
all input greatly appreciated !
Did you see this response that got posted? http://social.msdn.microsoft.com/Forums/en-US/vstest/thread/b26114a2-7a24-45eb-b5d1-01e9165045b0/
Just use the Extract Test like they suggest and you should work fine. Your Starts With could be "ExamAnswerId": " and your Ends With could be ". HTH.
I had a similar problem with the Extraction rule. Had to escape the quotes to get the condition to work. Like this:
Starts With: \"ExamAnswerId\":\"
Ends With: \"
Do following steps :
Add all available ExamAnswerId in a CSV file .
Now add CSV as Data source.
Lets suppose CSV file name is testdata and tableName=testData#csv and columnName=ExamAnswerId.
Please note when you will add data source you will see table name.
Replace this:
["ExamAnswerId": "757a3735-e626-412b-934c-e577c6963d51"]
by this:
["ExamAnswerId": "{{testdata.testdata#csv.ExamAnswerId}}"]
I managed session in JSON. The following link worked for me:
https://social.msdn.microsoft.com/Forums/vstudio/en-US/b26114a2-7a24-45eb-b5d1-01e9165045b0/cant-fetch-json-value-and-extract-to-parameter?forum=vstest
Example:
0x00000000 7B 22 53 65 73 73 69 6F 6E 22 3A 22 63 66 39 37 {"Session":"cf97
0x00000010 64 33 65 61 2D 36 39 38 33 2D 34 31 37 30 2D 38
I created "Extrat_Text" with variable MySessionID
Left Boundary "Session":
Right Boundary ",
Then I passed {{MySessionID}} in subsequent request in place of Session.
Or we can use regex (Positive look ahead and Positive look behind)
For example I want to get access_token property in a JSON result looks like this
{"token_type":"Bearer","expires_in":"3600","ext_expires_in":"0","expires_on":"1474420129","not_before":"1474416229","resource":"5fe3f443","access_token":"eyJ0eXAiOiJKV1QiLCJhbGci"}
I can use this regex:
(?<=\"access_token\"\:\").*(?=\")
I have a cuda loop where a variable cumul store an accumulation in double :
double cumulative_value = (double)0;
loop(...)
{
// ...
double valueY = computeValueY();
// ...
cumulative_value += valueY
}
This code is compiled on different SDK and run on two computers :
M1 : TeslaM2075 CUDA 5.0
M2 : TeslaM2075 CUDA 7.5
At step 10, results are differents. Values for this addition (double precision representation in hexadecimal) are:
0x 41 0d d3 17 34 79 27 4d => cumulative_value
+ 0x 40 b6 60 1d 78 6f 09 b0 => valueY
-------------------------------------------------------
=
0x 41 0e 86 18 20 3c 9f 9b (for M1)
0x 41 0e 86 18 20 3c 9f 9a (for M2)
Rounding mode is not specified as I can see in the ptx cuda file ( == add.f64) but M1 seems to use round to plus Infinity and M1 an other mode.
If I force M2 with one of the 4 rounding modes (__dadd_XX()) for this instruction, cumulative_value is always different than M1 even before step 10.
But if I force M1 and M2 with the same rounding mode, results are the same but not equals to M1 before modification.
My aim is to get M1 (cuda 5.0) results on M2 machine (cuda 7.5) but I don't understand the default rounding mode behavior at runtime. I am wondering if the rouding mode is dynamic at runtime if not specified. Do you have you an idea ?
After another ptx analysis and in my case, valueY is computed from a FMA instruction on cuda 5.0 while cuda 7.5 compiler uses MUL and ADD instructions. Cuda documentation explains there is only one rounding step using single FMA instruction while there are two rounding steps using MUL and ADD. Thank you very much for helping me :)