I ran into a problem. If I just run the application through AS, then everything works fine. It enters everywhere, everything opens, all functions are performed. As soon as I try to start Profiler, the application crashes immediately after being turned on. I went to the log and noticed something like this:
Fatal signal 11 (SIGSEGV), code 1 (SEGV_MAPERR), fault addr 0x10 in tid 5156 (HeapTaskDaemon), pid 5141 (d.myapplication)
Perhaps someone came across and can tell how to solve this problem.
Related
I'm handling a program which controls a car.
The program has a pretty large scale and it was made by other people.
So I don't understand completely how it works.
But I have to apply it and make a car moving.
The problem I'm facing is that the program often stalls with no error, no segmentation.
If it crashes, I can trace the cause with gdb or something like that.
But it does not crash, it silently stops.
How can I find the cause?
From your description - program silently stops - I understand that your program simply and gracefully exited, but not from your expected flow. This can happen for many reasons - for example, maybe your program enters illegal flow and some sub-component, such as standard library or other library decide that program should exit, and thus calls c-runtime exit() or directly calls Kernel32!ExitProcess().The best way to debug this flow is to attach a debugger and set a breakpoint on these two methods and find out who is calling them.If you mean your program enters a deadlock and halts then also you will need to attach a debugger and find out who is stuck.
I am using the spyder interface with a python script that works through many time steps in succession. At a random point in my code, the process will terminate and the console will say "kernel died, restarting...". I tried running the same script in pycharm and the process also terminates, seemingly at a random point, with some exit code which I assume means the same thing.
Anyone have any tips on how to get rid of this problem? Even a workaround so I can get some work done. This is incredibly frustrating.
Note: I recently moved and got a new router and internet service, not sure if that might affect things.
I have been dealing with intermittent crashing in our Electron application for the last month and have not been able to arrive at a solution. Crashing causes the Electron window to turn blank because the renderer process is dead but the main process is still alive.
Crashing doesn't seem connected to any particular user action. The app lasts about half an hour on average, but could crash after only 5 minutes or run for a couple hours.
Our stack is pretty standard, with React, Redux, and Sagas.
Here is the exception from the crash dump:
In crash-43.dmp the assembly instruction at node!v8::internal::IncrementalMarking::RecordWriteSlow+1187 in C:\Users\Motorized Precision2\Desktop\mpstudio\node_modules\electron\dist\node.dll from Node.js has caused an access violation exception (0xC0000005) when trying to read from memory location 0x0000000b on thread 0
and the stack trace:
node!v8::internal::IncrementalMarking::RecordWriteSlow+1187
node!v8::internal::StoreBuffer::StoreBufferOverflow+1786
node!v8::internal::CancelableTaskManager::TryAbort+25f
electron!GetHandleVerifier+9e849
electron!IsSandboxedProcess+22d87e6
electron!IsSandboxedProcess+22d7a36
electron!IsSandboxedProcess+22d58b4
electron!GetHandleVerifier+9e849
electron!GetHandleVerifier+47367
electron!GetHandleVerifier+45dba
electron!GetHandleVerifier+a0e86
electron!GetHandleVerifier+4283e
electron!IsSandboxedProcess+3b4634
electron!GetHandleVerifier+3463da
electron!GetHandleVerifier+3462cf
electron!GetHandleVerifier+f6d68
electron+116365
electron!IsSandboxedProcess+2cd4efb
kernel32!BaseThreadInitThunk+14
ntdll!RtlUserThreadStart+21
I have examined the renderer code very carefully to make sure that all listeners/timeouts are handled, and now I'm honestly just not sure what to do next. Is this a memory leak, or something else? Someone save us!
I'm debugging a particularly strange problem...
As a part of my team's test suite, we run a powershell script that calls an executable I wrote in C#.
Every blue-mooned Tuesday, the executable will hang indefinitely until we kill the process. Most days it works just fine, and I haven't gotten it to repro.
The curious part is that this exe hangs after it's done doing all it's work. It's output the last line of data and the main thread is exiting. There's no multithreading in this process, and CPU is at 0% and thread count is 1.
All I/O (other than console writes) is done earlier in the execution, and there's no exception catching anywhere, so if something throws we should see it.
I don't need a definitive "this is the issue," but I have no idea what could cause this behavior. If you could respond with any theories on why this would be happening (no matter how far fetched) that'd be great.
Version info
OS: Windows 2008 R2
Powershell: v2 (comes with R2)
.NET: v4
Heh, this is worth a shot. Got
Console.ReadLine()
anywhere at the end of some line of logic?
I've got a behaviour like that on one of my "C" console program. It was well working started via "CMD.EXE" but when I use it via "POWERSHELL.EXE" it hang (systematicaly) at the end of exécution.
In this code, there are keyboard pooling loop (while (! _kbhit()), and at the moment I solve the problem by consuming (getch()) the keydown that fired the last loop. I don't understand exactly why.
In the Powershell script the result of the exe file is affected to a var.
Anytime I have a badly behaving process (pegging CPU, or frozen, or otherwise acting strangely) I generally kill it, restart it and hope it doesn't happen again.
If I wanted to explore/understand the problem (i.e. debug someone else's broken program as it's running) what are my options?
I know (generally) of things like strace, lsof, dmesg, etc. But I'm not really sure of the best way start poking around productively.
Does anyone have a systematic approach for getting to the bottom of these issues? Or general suggestions? Or is killing & restarting really the best one can do?
Thanks.
If you have debugging symbols of the program in question installed, you can attach to it with gdb and look what is wrong there. Start gdb, type attach pid where pid is the process id of the program in question (you can find it via top or ps). Then type Ctrl-C to stop it. Saying backtrace gives you the call stack, that means it tells which line of code is currently running and which functions called the currently running function.