Tip: 看不到本站引用 Flickr 的图片? 下载 Firefox Access Flickr 插件 | AD: 订阅 DBA notes -- 
2010-03-03 Wed
最近又遇到类似错误，错误出现在INSERT操作时，错误出现，进程crash，任务失败，重新执行可以通过。
kcbgtcr 是Oracle数据库最重要的函数之一，其含义为：Kernal Cache Buffer GeT Cosistents Read,也就是数据库的一致性读操作，后面的代码有很多种，代表在不同的层面上出现问题。
Metalink 的 Note 415773.1 - Diagnostics and Solutions for kcbgtcr() Related Internal Errors记录了与此相关的很多问题。
不讨论具体的问题，根据代码的含义实际上可以知道，出现这类错误，基本上都是由于CR读异常导致的，CR读涉及的各个层面出现问题，如DataBlock,Undo Header,Undo Block出问题，都可能导致异常。
kcbgtcr_13号错误是指在构造一个CR读时，检查Buffer时发现其SCN不可用，判断出错导致代码异常，进程Crash掉，这类错误可能是Buffer过小，重用过快导致的，也可能是数据变更过于频繁导致。
这类错误极其少见，一旦出现要非常慎重的处理，有些Bug与此有关，需要通过Metalink确认，数据库在部署时最好应用最新的PSU。
下面是这次故障的错误堆栈摘要：
*** 2010-03-03 14:15:04.436
ksedmp: internal or fatal error
ORA-00600: internal error code, arguments: [kcbgtcr_13], [], [], [], [], [], [], []
Current SQL statement for this session:
INSERT INTO CT_INFO (RPT_DATE, RGN_CODE, .......
----- PL/SQL Call Stack -----
object line object
handle number name
700000206d666a0 338 procedure CT_INFO_S
7000001a89a3f30 3 anonymous block
----- Call Stack Trace -----
calling call entry argument values in hex
location type point (? means dubious value)
-------------------- -------- -------------------- ----------------------------
ksedst+001c bl ksedst1 FFFFFFFFFFED73C ? 000000006 ?
ksedmp+0290 bl ksedst 104A48040 ?
ksfdmp+0018 bl 03F326DC
kgerinv+00dc bl _ptrgl
kgeasnmierr+004c bl kgerinv 000000000 ? 10566823C ?
100000013 ? 225D0C00130000 ?
000000000 ?
kcbassertbd+0074 bl kgeasnmierr 1101955E0 ? 110450040 ?
105668AC4 ? 000000000 ?
000000000 ? 700000206F807C0 ?
000000000 ? 000000051 ?
kcbgtcr+2a68 bl kcbassertbd 105668AC0 ? FFFFFFFFFFEC608 ?
ktspgfbs+0144 bl kcbgtcr 102147B38 ? 000000000 ?
70000002EB3F448 ? 000000001 ?
ktspfsrch+00b8 bl ktspgfbs FFFFFFFFFFEE028 ? 000000000 ?
000000000 ? 000000000 ?
1101FFEF8 ? FFFFFFFFFFEDA78 ?
000000000 ?
ktspscan_bmb+021c bl ktspfsrch 700000010018078 ?
FFFFFFFFFFEE028 ?
ktspgsp_cbk1+07c4 bl ktspscan_bmb 1FE800000001 ?
ktspgsp_cbk+00a8 bl ktspgsp_cbk1 1130D0A00 ? 000000000 ?
1028F3668 ? FFFFFFFFFFEDF40 ?
11022A548 ? 110266D40 ?
000000000 ? 000000014 ?
kdtgsp+0504 bl ktspgsp_cbk 000000000 ? 000000000 ?
000000000 ? 000000000 ?
000000000 ? 000000000 ?
000000000 ? 000000000 ?
kdtgsph+02f8 bl kdtgsp 10500E820 ? 110195760 ?
kdtFlushBuf+0288 bl kdtgsph 1105F8E40 ? 000000000 ?
insflush+0348 bl kdtFlushBuf 1105F8E40 ?
insrow+0384 bl insflush 1105F8E40 ? 000000000 ?
1101BECF0 ? FFFFFFFFFFF13E0 ?
2C000100000004 ?
insdrv+0428 bl insrow 1105F8E40 ? FFFFFFFFFFF13E0 ?
000000000 ?
inscovexe+02b8 bl insdrv 1105F8E40 ?
insExecStmtExecIniE bl 01FA0954
ngine+005c
insexe+02f8 bl insExecStmtExecIniE FFFFFFFFFFF2318 ?
ngine FFFFFFFFFFF2310 ? 110527020 ?
opiexe+2738 bl insexe 1105942B8 ? FFFFFFFFFFF2978 ?
opipls+185c bl opiexe FFFFFFFFFFF3CC0 ?
FFFFFFFFFFF3DA8 ?
FFFFFFFFFFF3C60 ?
opiodr+0ae0 bl _ptrgl
rpidrus+01bc bl opiodr 66FFFF5A80 ? 6025E14E0 ?
FFFFFFFFFFF6B80 ? CE9A84B20 ?
skgmstack+00c8 bl _ptrgl
rpidru+0088 bl skgmstack 10233AE20 ? 000000000 ?
000000002 ? 000000000 ?
FFFFFFFFFFF6348 ?
rpiswu2+034c bl _ptrgl
rpidrv+095c bl rpiswu2 70000020458E188 ? 11052E3A0 ?
11046AA58 ? 000000000 ?
FFFFFFFFFFF6120 ?
3C00000000 ? 000000000 ?
000000000 ?
psddr0+02bc bl 03F32174
psdnal+01d0 bl psddr0 CFFFF6DB8 ? 6600000000 ?
FFFFFFFFFFF6B80 ?
30100BA3A8 ?
pevm_EXECC+01f8 bl _ptrgl
pfrinstr_EXECC+0070 bl pevm_EXECC 70000019DB5AC60 ? 000000000 ?
7000001C12D897A ?
pfrrun_no_tool+005c bl _ptrgl
pfrrun+1014 bl pfrrun_no_tool FFFFFFFFFFF6EE0 ?
7000001A89A3F30 ? 3100EAA30 ?
plsql_run+06b4 bl pfrrun 11048A228 ?
peicnt+0224 bl plsql_run 11048A228 ? 1000000000418 ?
000000000 ?
kkxexe+0250 bl peicnt FFFFFFFFFFF81F8 ? 11048A228 ?
opiexe+2ef8 bl kkxexe 110483218 ?
kpoal8+0edc bl opiexe FFFFFFFFFFFB814 ?
FFFFFFFFFFFB588 ?
FFFFFFFFFFF99E8 ?
opiodr+0ae0 bl _ptrgl
ttcpip+1020 bl _ptrgl
opitsk+1124 bl 01FA3344
opiino+0990 bl opitsk 000000000 ? 000000000 ?
opiodr+0ae0 bl _ptrgl
opidrv+0484 bl 01FA2198
sou2o+0090 bl opidrv 3C02DB56BC ? 44065F000 ?
FFFFFFFFFFFF750 ?
opimai_real+01bc bl 01F9FAB4
main+0098 bl opimai_real 000000000 ? 000000000 ?
__start+0098 bl main 000000000 ? 000000000 ?
--------------------- Binary Stack Dump ---------------------
-The End-
相关文章|Related Articles
- ORA-00600 3020 错误案例一则
- ORA-600 kcbzpbuf_1 坏块的恢复案例一则
- ORA-600 17285 错误 与 PL/SQL Developer
- Oracle HowTo: How to deal with Ora-600 4193 error
- Oracle Diag:如何处理ORA-600 2662错误
评论数量(0)|Add Comments
本文网址：http://www.eygle.com/archives/2010/03/kcbgtcr.html
换手机号码了，原号码永久保留电话功能，不再支持短信功能；
新号码，要知道我新号码，可以继续打原来号码问我的，嘿嘿。
Sometimes the best way to learn about a new technology or tool is to find a project that might be interesting to you, start playing with it and why not end up customizing and extending it to fit your needs.
While these days you can find tons of note taking applications for your mobile, desktop or “in the cloud”, I think this usecase is extremely easy to understand and it will allow you to focus on the underlying technologies and not some complicated logic.
Snip = Node.js + Redis ☞
This is a basic application that would allow you to store code snippets and have some syntax coloring when displaying them. Source code is available on ☞ bitbucket.
YourCached.info = MongoDB + Python ☞
Another basic application that allows you to store notes and bookmarks. A lot of functionality you’d expect from such an application is missing and that could be a good excuse for you to play with its source code available on ☞ GitHub and add exactly what you’d like.
I am pretty sure I have missed a lot of similar apps, so please do forward yours to be added to the list. I am pretty sure that building an extensive list like we did for NoSQL Twitter apps or NoSQL-based blog engines will be both fun and useful.
I have some doubts on how valid an M/M/m model is in a typical database performance scenario. Taking the example from the wait chapter of your book where you have a 0.49 second (service_time) query that you want to perform in less than a second, 95% percent of the time. The most important point here is the assumption of an exponential distribution for service_time immediately states that about 13% of the queries will take more than 2X(Average Service Time), and going the other way most likely to take 0 seconds. From just this assumption only, it is immediately clear that it is impossible to meet the design criteria without looking at anything else. From your article and link to the Kendall notation, wouldn’t an M/D/m model be more appropriate when looking at something like SQL query response time?? Something like M/M/m seems more suited to queueing at the supermarket, for example, and probably many other ‘human interactive’ scenarios compared to a single sub-component of an IT system.Here’s my answer, part 1.
RobB,
First, I believe your observation about the book example is correct. It is correct that if service times are exponentially distributed, then about 13% (13.5335%, more precisely) of those times will be 2S, where S is the mean service time. So in the problem I stated, it would be impossible to achieve subsecond response time in more than about 86% of executions, even if there were no competing workload at all. You’re right: you don't need a complicated model to figure that out. You could get that straight from the CDF of the exponential distribution.
However, I think the end of the example provides significant value, where it demonstrates how to use the M/M/m model to prove that you're not going to be able to meet your design criteria unless you can work the value of S down to .103 seconds or less (Optimizing Oracle Performance
Fig 9-26, p277). I’ve seen lots of people argue, “You need to tune that task,” but until M/M/m, I had never seen anyone be able to say what the necessary service time goal was, which of course varies as a function of the anticipated arrival rate. A numerical goal is what you need when you have developers who want to know when they’re finished writing code.With regard to whether real-life service times are really exponentially distributed, you’ve got me wondering now, myself. If service times are exponentially distributed, then for any mean service time S, there’s a 9.5% probability that a randomly selected service time will be less than .1S (in Mathematica, CDF[ExponentialDistribution[1/s],.1s] is 0.0951626 if 0.1s > 0). I’ve got to admit that at the moment, I’m baffled as to how this kind of distribution would model any real-life service process, human, IT, or otherwise.
On its face, it seems like a distribution that prohibits service times smaller than a certain minimum value would be a better model (or perhaps, as you suggest, even fixed service times, as in M/D/m). I think I’m missing something right now that I used to know, because I remember thinking about this previously.
I have two anecdotal pieces of evidence to consider.
One, nowhere in my library of books dedicated to the application of queueing theory to modeling computer software performance (that’s more than 6,000 pages, over 14 inches of material) does Kleinrock, Allen, Jain, Gunther, Menascé, et al mention an M/D/m queueing system. That’s no proof that M/D/m is not the right answer, but it’s information that implies that an awful lot of thinking has gone into the application of queueing theory to software applications without anyone deciding that M/D/m is important enough to write about.
Two, I’ve used M/M/m before in modeling a trading system for a huge investment management company. The response time predictions that M/M/m produced were spectacularly accurate. We did macro-level testing only, comparing response times predicted by M/M/m to actual response times measured by Tuxedo. We didn’t check to see whether service times were exponentially distributed, because the model results were consistently within 5% of perfect accuracy.
Neither of these is proof, of course, that M/M/m is superior in routine applicability to M/D/m. One question I want to answer is whether an M/D/m system would provide better or worse performance than a similar M/M/m system. My intuition is leaning in favor of believing that the M/M/m system would give better performance. If that’s true, then M/M/m is an optimistic model compared to M/D/m, which means that if a real-life system is M/D/m and an M/M/m model says it’s not going to meet requirements, then it assuredly won’t.
I did find a paper online by G. J. Franx about M/D/m queueing. Maybe that paper contains an R=f(λ,μ) function that I can use to model an M/D/m system, which would enable me to do the comparison. I’ll look into it.
Then there’s the issue of whether M/M/m or M/D/m is a more appropriate model for a given real circumstance. The answer to that is simple: test your service times to see if they’re exponentially distributed. The Perl code in Optimizing Oracle Performance
, pages 248–254 will do that for you.
I just found this post from Ivan Voras which is covering exactly what I’ve written a while back about MongoDB durability being a tradeoff. As a plus, Ivan’s post also includes a quick summary of various file system durability methods:
- fully synchronous writes
- partially synchronous writes
- logging
- journaling
- soft updates
I only hope that based on these two posts, all MongoDB users will become aware of the MongoDB durability behavior (or differently put durability tradeoff).
I think this should become part of the official Cassandra documentation.
When building a Cassandra cluster, the “key” question (sorry, that’s weak) is whether to use the RandomPartitioner (RP), or the OrderPreservingPartitioner (OPP). These control how your data is distributed over your nodes. Once you have chosen your partitioner, you cannot change without wiping your data, so think carefully!
Dennis Forbes has a ☞ great post about RDBMS scalability and the hype around NoSQL that ends up with something like “SQL is scalable and NoSQL isn’t for everyone”. I have posted a long comment to the original post, reproduced below for reference, and suggested a slight modification to that conclusion: SQL is scalable. SQL scalability isn’t for everyone. NoSQL isn’t for everyone either (nb SQL should be read in the context of the post as RDBMS.)
Below is my original comment:
The part I agree most is: “In the case of the NoSQL hype, it isn’t generally the inventors over-stating its relevance — most of them are quite brilliant, pragmatic devs — but instead it is loads and loads of terrible-at-SQL developers who hope this movement invalidates their weakness.”
Over MyNoSQL (a blog focused on NoSQL technologies), most of the people talking about real life uses of NoSQL mention the operational costs of RDBMS scaling (f.e. Twitter usage of Cassandra), a point that your post seem to agree upon too. Personally, I tend to believe that NoSQL as RDBMS are just tools for our job and there is nothing about the death of one of the other. But as we’ve learned over years, every new programming language is the death of all its precursors, every new programming paradigm is the death of everything that existed before and so on. The part that some seem to be missing or ignoring deliberately is that in most of these cases this death have never really happened. And I think the same will apply to NoSQL and RDBMS and OODB and etc.
As a side note, I’d say that the definition you are using for scalability, while not incorrect, is a bit too wide. I think Wikipedia definition is giving a more clearly delimitated definition. I have also found Jonathan Ellis presentation on scalability quite useful and easy to grok for everyone.
Last, but not least, while I do like your ending note: “SQL is Scalable and NoSQL Isn’t For Everyone”, I’d say that an even better one would be “SQL is scalable. SQL scalability isn’t for everyone. NoSQL isn’t for everyone either”.
推荐几个ronald bradford发布在SlideShare上的ppt.
No related posts.
您想验证自己的IT潜质吗？
您想开启互联网职业之门吗？
您想寻求一个施展IT技术的舞台吗？
学习就是工作，挑战自己，只等你来。体验全新校园招聘模式。
岗位要求：理工科专业本科学历，有较强的学习能力和责任心，熟悉互联网。
职位详情查询请登陆支付宝招聘网站：http://job.alipay.com/
简历投递邮箱：resume@alipay.com
No related posts.
Author: AnySQL, published on dbatools.net, Oracle Data Recovery, Tools, WebChart Report, etc.
Some people like to run WebChart demo application on Oracle database, while some other people may like to run WebChart demo application on MySQL database. Seems I have to write two WebChart demo applications, one for Oracle, another one for MySQL database.
I think I should not ask customer to use Oracle or MySQL, WebChart should support almost all major different database systems. It's possible now to define different SQLs for different databases, for example, we define the following SQLs as the data source of one WebChart page.
WEBCHART.QUERY_1=*
WEBCHART.QUERY_ORACLE_1=select
to_char(trade_month,'yyyy/mm') month ,
trade_count count
from trade_monthly_summary
where to_char(trade_month,'yyyy')='2008'
WEBCHART.QUERY_MYSQL_1=select
trade_month,
trade_count+0 as count
from trade_summary_monthly
where year(trade_month) = 2008
When connect to Oracle, it will run the SQL defined for the Oracle database, when connect to MySQL, it will run the SQL defined for the MySQL database. It's possible to create one demo application to work fine for both Oracle and MySQL, and other different types of databases.
Related Posts
Twitter Me? | Leave New Comment(Current: 0)
Link: http://www.dbatools.net/mytools/webchart-multidb-support.html
2010-03-02 Tue
2010-03-01 Mon
AnySQL.net
Oracle & Starcraft
Give you some color to see see!
Oracle Scratchpad
Oracle Life
Chanel [K]
Oracle Security Blog
MySQL Performance Blog
The Tom Kyte Blog
Delicious/Fenng/oracle
O'Reilly Databases
Red Hat Magazine
车东[Blog^2]
blue_prince
玉面飞龙的BLOG
木匠 Creative and Flexible
生活帮-LifeBang
Hey!! Sky!
dba on unix
Brotherxiao's Home
jametong's shared items in Google Reader
DBA Tools
Inside the Oracle Optimizer - Removing the black magic
DBA@Taobao
存储部落
OracleBlog.cn
知道分子
支付宝官方 Blog - 支付志
木匠的天空 Oracle Architect and Developer
Hello DBA
OS与Oracle
Cary Millsap
Guy Harrison's main page
eagle's home
dbthink
DBA Notes
OracleDBA Blog---三少个人涂鸦地！
The Pythian Blog
MyNoSQL