decoration decoration

When you want to know more...
For layout only
Site Map
About Groklaw
Legal Research
ApplevSamsung p.2
Cast: Lawyers
Comes v. MS
Gordon v MS
IV v. Google
Legal Docs
MS Litigations
News Picks
Novell v. MS
Novell-MS Deal
OOXML Appeals
Quote Database
Red Hat v SCO
Salus Book
SCEA v Hotz
SCO Appeals
SCO Bankruptcy
SCO Financials
SCO Overview
SCO v Novell
Sean Daly
Software Patents
Switch to Linux
Unix Books
Your contributions keep Groklaw going.
To donate to Groklaw 2.0:

Groklaw Gear

Click here to send an email to the editor of this weblog.

To read comments to this article, go here
Reports from the Oracle v. Google Trial - Day 6, Patent Phase - Drs. August and Mitchell , ~pj - Updated 5Xs
Monday, May 14 2012 @ 01:06 PM EDT

The judge has ruled on the weird Oracle motion [PDF] to delay the damages phase of the trial to get a new jury. It's a no from Judge William Alsup, also calling their position on the 9 lines of code and the test files and damages "super extreme". They'll have to present it to *this* jury. There's no way the law should allow a disgorgement theory over millions or billions of dollars for nine lines of code, the judge tells them, our man in the courtroom tells us. The 37 APIs will not be part of phase three, "because liability has not been proven on that". So that's that. Google's motion for summary judgment on copyright damages [PDF] is also denied. It's on to the damages phase after closing statements by tomorrow, with this jury. Meanwhile, Google expert Dr. David August, who testified on Friday, is back on the witness stand.

Jump To Comments

[Update 1, Update 2,
Update 3, Update 4, Update 5]

Here's the first report on the discussions prior to the jury entering the room:
5/14/12, 7:31am

Stipulation to try willfulness in phase 2- seems ok with judge, but wants to make sure he understands the impact.

Some dispute as to what evidence would be presented for this. Google wants an instruction that willfulness is to be measured before the lawsuit is filed, doesn’t want post-litigation conduct involved. Oracle wants to argue that Google has been willful because Rubin testified that no changes were made after Oracle gave notice.

Jacobs: [Seagate?] says that ordinarily pre-litigation conduct is what is necessary.

Judge Alsup: So why don’t we do what is ordinary?

Jacobs: Because this is extraordinary. [chuckles…]

Judge Alsup: The Lindholm email doesn’t say “my god” look at this ‘520 patent, my god look at this ‘104 patent. We’ve got to look at these… I don’t know the answer to this, a moving target. Limit the instruction to pre-litigation conduct and will Google be allowed to put in evidence about the re-examinations to show non-willfulness? Is there such a thing as willful indirect infringement or is it only direct infringement?

Google: Only for direct infringement.

Willfulness will go to the jury in phase 2! Judge to decide the pre-litigation and re-examination issues.

[This all goes back to the Lindholm email. Oracle wants to bring it back to demonstrate Google’s willfulness. Aren’t we all sick of this by now?]

Judge has prepared new jury instructions, special verdict form.

Judge Alsup: Leaves a false impression if Oracle argues that Google didn’t do anything all this time after the lawsuit was filed because the patents were under PTO review.

Oracle: But validity isn’t at issue here. Also there was long time between the lawsuit and when the re-examination was filed.

Judge Alsup: This is going to be a mess if we get into post-complaint stuff. No post-complaint stuff. Jury instruction will say not to speculate about events after the filing of the complaint and willfulness is up to the day of the complaint. Wants briefs on whether willfulness applies to direct/indirect.

Judge isn’t buying the idea that Google just sat on the issue; they went to the PTO and were pretty successful in these actions.

Some quibbling over definitions in the instructions. Can a symbolic reference be a number? Oracle also asking to redefine dynamic/static.

Jacobs: Dynamically doesn’t mean the same thing as run-time. We’re misunderstanding the basic rules of set theory.

[PJ: All the techies here at Groklaw call this statement an absolute howler. Here's a comment and some more that will explain why they think Mr. Jacobs is so, so far off. It's very hard for the techies here, who actually do write this kind of code and know exactly how it works, to listen to the lawyers say things like this, without wincing. They do allow that perhaps he was misquoted. We'll wait for the court transcripts to be certain.]

Judge Alsup: Re Google’s proposed changes in jury instructions: Didn’t I reject most of your augments at the charging conference?

The willful blindness instruction. If it does go in, Google wants more context, should require active acts and not just passive ones to avoid learning of patents. The decision not to take an action is not an active act.

Judge Alsup:: You’ve seen in the movies a hundred times when a guy raises his hand and says “Stop. I don’t want to know that. Don’t tell me that.” You can argue the facts to the jury.

Google: Shouldn’t have to argue it because the facts don’t support it.

Instructions 19-20: Google doesn’t want “mobile service providers” involved. Oracle says that Rubin testified that phones were sold through Verizon.

All of these motions are denied.

If liability is established for patents, we’ll have a damages phase on patents. In any event, there will be a damages phase on the decompiled code and rangeChceck. No damages phase on the main copyright issues because liability not established. “The court totally rejects Oracle’s argument, and I don’t even understand the argument. You get a favorable verdict on question 3 and the time to deliver on damages is phase 3.” Nothing else goes in phase 3 because no liability has been shown. We’re not going to get into the 39 packages because liability has not been proven on that.

If the day ever comes when that is established, we’ll have a new trial on that issue.

Judge Alsup: Motion for summary judgement: No way the law should allow a disgorgement theory over millions or billions of dollars for nine lines. Mr. Jacobs wants his day in court and he can have that. “Super extreme, hyper extreme proposition.”

Update: And a second report:

Subject to a condition, parties have agreed to make indirect infringement follow automatically from a finding of direct infringement (inducement or contributory). This would streamline things for the jury. Condition is that both parties need to reconfigure closings. Both would need to close by tomorrow. That’s what they'll do. Indirect infringement is out of the instructions and jury form. If the jury finds direct infringement, the court shall enter a judgment for both direct and indirect infringement.

So if the jury finds infringement, Google would be liable for the handsets? Some quibbling over the exact intent, but they are basically in agreement. Oracle asks for a sidebar.

Judge Alsup: Is this something the witness can’t hear or something the public can’t hear? [jury is not in the room] No sidebar happens.

Would be binding on Google but not on Motorola or anyone else because they aren’t present.

Caleb Garling of Wired also tweeted this tidbit:
Dr August (Google's expert) rebuking Dr Mitchell (Oracle's). Mitchell is sitting attentively, listening, but betraying no emotion
The judge believed that he had to overrule the jury on the test files, because Mitchell said they were very important (--so important Google didn't even know they were there until Oracle told them since it wasn't Google who put them there, m'lords?), and he wrote in his order that no one contradicted that testimony, and that's why he had to rule as a matter of law that the evidence from Dr. Mitchell established the point. As we see here, Google is not taking any chances that it could happen again.

I don't see why a jury can't decide they don't believe a word that man said, if that is their decision. The jury instructions say that is their job, to evaluate credibility. If they didn't believe Dr. Mitchell, as I didn't, why can't they so decide? I know. Logic. Mark tells me I'm off base on this. For the jury to reach a different conclusion, he explained to me, there would have to be evidence that Dr. Mitchell's statement was unfounded (Google's burden of proof) or that there was contradictory evidence (Google's burden of proof). The jury can't simply decide that Mitchell's testimony was not credible absent some challenge or contradictory evidence. To which I say, why not? If on other issues, where there was evidence, they listened and decided nothing he said was credible, why shouldn't that be their job and their right? Sometimes the law and logic diverge, as you may have noticed.

: )

It looks like the patent phase is coming down to a battle of the experts, with Oracle's Dr. Mitchell claiming one thing and Google's Dr. August the opposite regarding patents. Ginny LaRoe tweets:

Google expert: "Android doesn't contain symbolic references of any kind ... so there's no infringement."
The argument has to do with whether Dalvik does what the Oracle patents describes, and on Friday, Dr. August, another expert Terrence Parr, and Andrew McFadden, who wrote Dalvik, were very clear that it does not.

Both Google and Oracle have rested. We have heard all the evidence for the patent phase. Closing arguments in the morning. The jury has gone home for the day.

Update 2: Zach has a fuller report now, taking us through to the point where Google rests but before Oracle's rebuttal:

OK here's the next part of the notes, covering Dr. August's testimony through Google resting its case. I'll have notes from Oracle's furthering questioning of Dr. Mitchell later this afternoon.

8:09 AM – jury enters

Judge Alsup: welcome back. Hope you all enjoyed Mother’s Day weekend. Plan to finish evidence today, not sure whether we’ll get to closing arguments.

Direct Examination of Dr. David August Continues from Friday

Google: Looking at the claim construction for a symbolic reference: “a reference that identifies data by a name other than the numeric memory location of the data, and that is resolved dynamically rather than statically” With this, do dexopt and resolve.c infringe the ‘104 patent?

August: No. They do not operate on instructions that contain symbolic references.

Pulls up Mr. Andrew McFadden’s chart [ed. we can’t see it]. Asks Dr. August to walk through the dex file instructions and explain what is a symbolic and what is numeric reference.

August: [Fumbling to get a pointer stick and arrange the flip chart.] Here we have an instruction 52 and a single operand 01. What is that operand 01? Let’s apply the court’s claim construction and see. “A reference that identifies data.” But does it do so by name other than numeric memory location? Looking at this, 01 directly refers to the location of the data; the entry is at memory location 01. So the claim construction doesn’t apply. This is not a symbolic reference.

Google: Where is that entry 01 located?

August: A reference located in the instruction stream.

Google: Where does it point?

August: An entry in the field ID table in the data portion of the program.

Google: Let’s move to the field ID table. Do the data there qualify as symbolic references?

August: A two-part question as there are two pieces of data: yellow and magenta. Start with 02. It is a reference that identifies data, but 02 is the location of that data, so it’s not a symbolic reference.

Google: What about the 76 in the field id table?

August: The 76 also refers to data, identifies data. 76 is the location in the table in which is occurs, so it is also the numeric memory location.

Google: Is the 01 in the instruction stream referred to as an index?

August: Yes. It’s an index into the table. [This is basic C pointers stuff.]

Google: What’s the difference between an index and an offset?

August: Both are locations. Offset may be used more commonly when talking about how many bytes into a table you want to traverse. Index more commonly used for tables with larger size entries.

Google: At entry 76 in the string id table, is that a symbolic reference?

August: No, a numeric reference. Doesn’t fit the construction because it identifies the data by location.

Google: String data at entry 8 (string “fun” again). Is that symbolic reference?

August: It is a reference that identifies data. It’s not shown on this board, but I know from looking at the code that it is. To find “fun,” we need to resolve it by looking for the location where it refers to. In resolve.c, this is resolved dynamically, so this does qualify under the claim construction as a symbolic reference.

Google: What about in the course of dexopt? Would it qualify as a symbolic reference?

August: Not if it is resolved statically. Dexopt is a static linking process, so it operates statically and not dynamically.

Google: Were you here for Dr. Mitchell’s testimony? Did you hear him explain that some of the dexopt references were symbolic references?

August: Yes. Dr. Mitchell is saying that all these are symbolic references.

Google: How do you explain the difference in your opinions?

August: Mitchell is applying the court’s claim construction differently.

[Puts the chart away and Dr. August goes back to the stand]

Google: Let’s talk about resolve.c. Did you review this list of functions? What are they? [dvmResolveClass(), dvmResolveMethod(), etc…)

August: I reviewed all of them. These are the methods/functions that take numeric references from the instruction, goes through the process we just did, and along the way may resolve a symbolic reference in the data just like “fun” over there.

Google: Do you agree with Dr. Mitchell that these functions infringe the ‘104 patent?

August: No. They do not resolve symbolic references. Each function takes an index from the instruction and those indexes are numeric references, not symbolic.

[Shows TX 737: Dalvik VM Instruction Formats. Page 2, syntax section.]

Google: Does this tell you what composes an instruction?

August: Yes. Syntax tells you what makes up an instruction: “each instruction starts with an opcode and...” Defines instructions as I understand them.

Google: “Arguments which indicate a literal constant pool index…” What is this talking about?

August: Talks about the arguments in some instructions. These arguments are indexes into certain constant pools like the string pool index and the type pool index. These are the same thing we were just talking about in resolve.c

[Third page. Opcode formats.]

August: There are a limited number of shapes that opcodes can take. One is the 22c format. One of those is “op va vb type@cccc” or “op va vb field@cccc.”

Google: Have you seen a comment in the code about symbolic references or resolution in Dalvik?

August: Yes. Numerous times.

Google: Does this suggest the ‘104 patent may be infringed?

August: No. Resolution occurs on symbolic references in the instructions, not in the data.

[Looks at Dr. Mitchell’s slide with the comments. ] It only takes about resolution like we see elsewhere, not symbolic references.

Google: Are there symbolic references ever in instructions?

August: No. I’ve looked at all the instruction formats and can say that the instructions do not contain symbolic references.

[Another set of resolve.c comments.]

August: Does not suggest that there are symbolic references in the Dalvik bytecode.

Google: Claim 11. Does resolve.c infringe claim 11 of the ‘104 patent?

August: Claim 11 requires that instructions contain dynamic references (“said instructions containing one or more symbolic references”. Dalvik instructions do not.

Claim 39. Also not infringed by resolve.c for the same reason. Claim requires a “symbolic field reference” in the instruction. A symbolic field reference is a type of symbolic references. No symbolic references here.

Same song and dance with claim 40, 41. No symbolic references in the instructions.

Google: Changing gears, let’s talk about dexopt. Do you believe that infringes the ‘104 patent?

August: No. For two reasons. The first is the same we’ve been discussing: instructions do not contain symbolic references and these claims require that they do.

Google: Do the dexopt docs suggest that there are no symbolic references in the instructions on which it operates?

August: It makes that suggestion.

[A comment in dexopt code. Argument @cccc is a constant pool offset. Showing where that is on the example dex code chart. ] Slide 48 from Dr. Mitchell. Showing instructions produced by the rewriting process in dexopt. Exchanging one offset/numeric reference for another.

Google: With respect to the arguments that go into these opcodes, how are they changing if at all?

August: Dexopt goes through the instructions. When it finds an iget, it takes the numeric memory location, goes through the process we did on the board, does resolution when it gets to that “fun.” The result of that is an offset. It writes that offset into the instruction and changes the instruction to an iget_quick.

Google: Is it rewriting the field@cccc instruction?

August: Yes. It takes that index into the field id table (numeric memory location) and replaces that into an offset. An offset replaces an index.

Looking at the same thing using the example in the Dalvik docs. Same conclusion.

TX 46.106. A header file from Dalvik that lists the instruction formats. Shows where the formats we’re talking about are listed.

Google: What do these documents suggest to you about whether symbolic references are used in Dalvik bytecode instructions?

August: Line 57 and 58 show that the instructions contain a memory index/field offset, not symbolic references.

Google: What’s the second reason you mentioned earlier?

August: Claim construction says that resolution occur dynamically.

[Oracle renews its standing objection to this claim construction.]

Google: Why does dexopt do static resolution?

August: It does static linking, must run before the program executes.

Google: You said linking? Does linking involve resolution?

August: The resolution process involved doing a search to find “fun.” We needed to link “fun” as referenced here with the location where it is defined. Linking is one form of resolution.

Google: Did you consider Dan Bornstein’s description of dexopt?

August: Yes. He talks about it as a static process, install-time work.

TX 32 slide 35. Install-Time work: “static linking”

This is consistent with my examination of the code. Static linking is what dexopt does. Dexopt operates on the application to do this resolution when it arrives on the phone.

TX 35: Bytecode for the Dalvik VM

When installed on a running system, some instructions may be altered “as an install-time static linking optimization.”

[Google pulls out a bunch of places in a whole bunch of docs where it says “static linking”]

Google: Does the Dalvik optimizer do any optimizations that can only be done at runtime?

A: No. It only does the ones with information that can be inferred statically.

Back to the claim charts.

Google: Does dexopt infringe claim 27 of the ‘104 patent?

August: No. Instructions do not contain symbolic references and the resolution is not occurring dynamically.

Google: Now claim 29?

August: No. [Google’s slides - draws a cute red X next to the claim after he says this]

Google: The ‘104 patent is a reissue correct?

August: Yes.

Google: Looking at the patent’s cover. Says a reissue of the ‘685 patent. Are those claims here?

[Oracle objects that this isn’t in the report. Google can talk about at closing but not now. ed: Relevant because Lindholm refers to the ‘685 patent in one edition of his book, IIRC.]

Q: Are you familiar with Mr. Van Det and his performance benchmarking?

A: Yes. There are three issues with his results: First, measurements were performed on the VM, but the VM isn’t always running. So the results are overstated.

What does it mean that the VM isn’t always running? There’s native code, the just-in-time compiler. During those operations, the VM’s performance is not an issue.

Second, benchmarks are not the same as the applications that users use. The benchmarks are at best an approximation.

Third, He deactivated part of Android that’s not used here: the JIT. This is problem because the JIT performs many optimizations. It’s not fair to turn off the JIT for these tests. The JIT is not accused of infringing the ‘104 patent.

Google: What does the JIT do?

August: It observes the instructions being executed. If it seems some are being executed frequently, it stops the VM, grabs those instructions, and converts them to native code, which can execute more efficiently.

Q: What would turning it off do?

A: The JIT can give significant performance improvements.

Cross-examination of Dr. August by Oracle:
[Yay, we’re back to the flip chart with bytecode]

Oracle: What does the “52 01” mean?

August: Opcode and a modification on that action. i_get 01

Oracle: What does that mean?

August: Take the index in the instruction, find the location in the field id stable to get an offset, take that offset and apply it to the instance object, and put whatever is there in another location called a register.

[switching charts]

Oracle: We changed “fun” to “y” at the judge’s request, but that doesn’t change anything.

So i_get 01 means obtain the value of the field from the instance object and place it in the register?

August: That’s the last step in the process, yes.

[Oracle counsel trying to figure out how to draw the instance object on his chart]

Oracle: Does 01 uniquely represent the value of a field in the instance object?

August: No.

Oracle: So 01 could get you randomly different fields in the instance object.

August: No, it doesn’t work like that. But if you have a second dexopt file that refers to the same instance object, it may be 08 or something else.

Oracle: So is 01 the offset in the instance object?

August: No, it is not.

Oracle: The purpose of the i_get instruction is to obtain data from an instance object?

August: Yes, that’s the last step.

Oracle: Again, the 01 is not a numerical value in the instance object is it? [really triumphantly]

August: No. It’s a location in the data table.

Oracle: When Dan Bornstein testified, did you detect any inaccuracies?

August: No.

Oracle: And same with Andy McFadden?

August: No.

Oracle: Looking at figure 1A of the ‘104 patent, a load operation. Operand is 2. 2 is not the data being obtained?

August: True.

Oracle: The 2 is a numeric memory location?

August: Yes.

Oracle: So the data being obtained here is the actual value in the data object (17)?

August: True.

Oracle: Now figure 1B: “load y” -- Is y a symbolic reference?

August: Yes.

Oracle: The actual data to be obtained is the value 17 here too, right?

August: Yes.

[Google objects to the term “actual data.” Oracle rephrases]

August: The 17 is not used to find the location of itself. The data in the data object is not used to determine the correspondence between the symbolic reference and a numeric memory location. So 1A refers to the data as a numeric memory location while 1B refers to it with a symbolic reference. [Basically, Oracle is trying to get him to agree as much as possible and pointing out that the end result is the same as that described in the patent.]

[PJ: May I just point out that the end result being the same isn't the issue with a patent. It's how you get there.]

[15-minute break for the jury. This is Google’s last witness. Oracle will have a rebuttal case (maybe an hour) and Google will have some cross there. May have time for the closings today.]

Huddles all around. Google has obtained a case of bottled water, while Oracle makes do with the few pint-sized bottles on their tables. Google slideshow guy reading Yahoo News and Mail on his computer. The court reporter manages to lock herself in the courtroom. She knocks on door, and along comes the judge ready to start up again. Oops.

Some progress! Subject to a condition, parties have agreed to make indirect infringement follow automatically from a finding of direct infringement (inducement or contributory). This would streamline things for the jury. Condition is that both parties need to reconfigure closings. Both would need to close tomorrow. That’s what we do. Indirect infringement is out of the instructions and jury form. If the jury finds direct infringement, the court shall enter a judgment for both direct and indirect infringement.

So if the jury finds infringement, Google would be liable for the handsets? Some quibbling over the exact intent, but they are basically in agreement.

Oracle asks for a sidebar.

Judge Alsup: Is this something the witness can’t hear or something the public can’t hear? [jury is not back yet] No sidebar happens. Would be binding on Google but not on Motorola or anyone else because they aren’t present.

Jury’s back and so is Dr. August.

Dr. August Cross, Continues

Still looking at the figures from the patent. Tries to get August to say that the i_get instruction stores the “actual field data” into the register. Google objects again to “actual data.” Oracle shows McFadden’s testimony where he talks about the “actual data.” Oracle: So the i_get instruction has as an operand the field index?

August: Yes.

Oracle: And you heard Mr. McFadden testify that the field index is not the numeric memory location of the actual field data in an object?

August: True.

[Oracle asks this exact question again for emphasis]

Comparing parts of the diagram to the patent. Agrees that the values in the instance object are like the “17” in the patent diagram.

Oracle: You testified that Dalvik bytecodes do not contain dynamic references at all?

August: Right.

[His report is a hefty tome.]

His report says “Dalvik VM does not define an instruction format that contains a symbolic reference.” In other words, you can’t put “y” or “fun” into the instruction stream. That’s because operands must have a fixed length.

Oracle: In fact, the format of the dex compiler here is in all respects the same as that of the Java compiler?

August: In terms of this specific instruction, fundamentally yes.

Oracle: So the operands are a fixed length in both a dex file and a .class file?

August: I believe so.

Oracle: So it would also be true for a Java bytecode instruction? Is it your testimony that there are symbolic references in the instruction stream output by the javac compiler?

August: I believe it does not output symbolic references.

Oracle: So Java doesn’t do this either?

[Google jumps up at this. Says it doesn’t matter what Java does. Judge Alsup sustains: the only thing that matters is the patent, not whatever Java does.]

Oracle: You agree that Dalvik instructions contain references to methods, classes, fields, strings?

August: They can contain references to these things in constant pool tables.

Oracle: And can those be symbolic references?

A: No. They are actual locations.

[Oracle is basically trying to get him to agree that it uses a symbolic reference because none of the operands are the numeric memory location of the field data. Dr. August says it’s clear that field@cccc is referring to the field id table.]

[Someone in front of me has done a great pen and ink drawing on his legal pad of the judge, Dr. August, and a sleeping jury. I’m actually impressed the jury is this with it given the insane level of pedantic quibbling we’ve gotten into.]

Oracle: So dexopt replaces a field@cccc with a byte offset that is a numeric reference?

August: Yes.

Oracle: So your testimony is that dexopt rewrites the i_get instruction into an i_getquick instruction and converts the operand into a numeric reference?

August: Yes.

Oracle: And do you agree that a dex file contains symbolic references when it arrives on the device?

August: Yes.

Oracle: Do you agree that the Dalvik VM resolves functions dynamically?

August: It does.

Oracle: And you were here when Dan Bornstein testified that dexopt is part of the Dalvik VM?

August: Yes.

Oracle: And you agree?

August: They share the same code.

Oracle: And dexopt loads the dex file into the Dalvik VM?

August: No. Dexopt processes the file that is placed on the device.

Oracle: Dexopt processes the file while the Dalvik VM is running, true?

August: Not for the same program.

Oracle: That’s not what I asked. Is the Dalvik VM running?

August: Sometimes.

Oracle: Let’s see what Mr. McFadden said. He said that Dexopt processes the dex file while the Dalvik VM is running. Do you disagree?

August: I don’t disagree. I’m just being more specific.

Oracle: Dexopt loads the dex file into the Dalvik VM, true? When dexopt loads the file into dexopt, it loads it into the Dalvik VM?

August: If you mean the code that is a part of Dexopt, yes.

Oracle: Let’s talk performance testing. You didn’t do those things yourself that you think should have been done differently?

August: No.

Oracle: And you did no performance testing yourself at all?

August: No.

Oracle: And Google, with all its resources, didn’t provide you with any performance data for your report?

August: No.

Oracle: Both benchmarking tools are standard tools? Google uses them internally for their own tests?

August: Yes.

Oracle: Back to instruction “52 01.” What this instruction does is get the actual field data and place it in a register?

August: True.

Oracle: And the 01 is not the numeric memory location?

[Tries to force him to agree that since the “01” is not the final numeric memory location, it must be a symbolic reference.] August: 01 is a reference and it does identify data.

Oracle: So the reference 01 identifies that data by a name other than the numeric memory location of the data?

August: The reference identifies data, but the data is the field id table. That’s not applying the court’s construction.

Oracle: Start with the first half of the definition: “A reference that identifies data other than by the numeric memory location of the data” (second part is that it does so dynamically). So let’s assume the data is actual field data in the instance object. The 01 does identify that data, true?

August: No. It refers to the field ID table.

Oracle: Even though “52 01” will retrieve the field data from the instance object, your testimony is that 01 doesn’t refer to the data in the instance object?

August: That’s correct.

[Everyone’s head starts to explode keeping track of what assumptions we’re making.]

Oracle: You don’t think the 01 identifies the data? So when Mr. Mcfadden testified about how this all works, you disagree with him?

August: No.

Google’s redirect of Dr. August:
Google: Points to claim construction. Does the entry in the string id table refer to data by a name other than the numeric memory location?

August: No, it’s a numeric reference.

Google: There’s been a lot of talk about the “actual field data in the instance object.” So let’s talk about the instance object. This entry at slot 18 (an offset), what can be in that instance object by way of data?

August: It could be a symbolic reference, a numeric reference, or other non-reference data.

Google: And in Dalvik, is the data in these entries always non-reference data?

August: No, it’s not. You can write programs that contain references in instance data of objects.

[Walks through the process of resolving variables again, describing everything is numeric memory locations]

Google: And in dexopt, can you explain whether and how the VM is running while dexopt is processing Dalvik bytecode?

August: The VM may be doing other things as it relates to other programs. When your device is on, many things are running. But as it relates to the program being installed, dexopt may start and stop before the VM interpreter can interpret it.

Google: TX 739, about the “backdoor into the VM.” What does that mean?

August: The VM has a lot of code. It is like a library and you can think of that library as having an API. The dexopt program is much smaller because it can leverage the code in the VM library.

Google: The jury is all too familiar with APIs… [chuckles]

August: And when it says here that dexopt completes, what does that mean? So not only does dexopt not execute dynamically, but dexopt terminates (stops its own execution) and is no longer running when it is done.

Google: Again, is dexopt dynamic or static?

August: Static. Everything it does is before the first execution of the program.

Google: Does dexopt resolve symbolic references?

August: No.

Google: Why do you say no?

August: Because it operates statically rather than dynamically. So it doesn’t satisfy the definition under the court’s claim construction.

Oracle tries to question Dr. August again.

Judge Alsup: Wait a minute. How many times are you going to go through this? They agree on five more minutes.

Oracle's Last Try to Shake Dr. August:

We go through the resolution process again, establish that the end result is still the same.

Oracle: After i_get is resolved, it takes you into a unique location in the instance object?

August: Right. [Tries to explain further… Gets cut off]

We’re done with Dr. August, much to his relief.

Google rests.

Judge Alsup: another milestone has been reached. Oracle has a rebuttal case, wants to recall Dr. Mitchell.

So stop back later, and we will finish. Meanwhile, Oracle would like us to look at their opening slides [PDF]. Comments are highlighting that there has historically been a monetary connection between Oracle and Stanford University [Cf. PDF], where Dr. Mitchell works.

Update 3: And TechDirt provided a link to James Grimmelmann's analysis of a ruling on Friday regarding fair use and de minimis use by a state university:

On Friday, the long-awaited decision [PDF] in the Georgia State e-reserves case (a.k.a. Cambridge University Press v. Becker) dropped. By way of context, the case is a challenge by three academic publishers (Oxford University Press, Cambridge University Press, and Sage Publications) against Georgia State University’s e-reserves policy....

First, over a third of the claims didn’t even make it to the fair use stage at the heart of the case. In many cases, the publishers were unable to prove to the court’s satisfaction that they owned the copyright in the portions of the books that were copied and uploaded. Sometimes they couldn’t produce a timely registration certificate and there were proof problems with originality; sometimes they couldn’t find a work-made-for-hire agreement or copyright assignment from the authors of individual chapters in edited volumes. The court was unsympathetic: no documented chain of title, no lawsuit. There’s a looming e-rights mess, loosely akin to the robosigning mess around ownership of securitized mortgages: in both cases, the putative owners don’t have all their papers in order. This opinion either recognizes or contributes to the mess, depending on your point of view.

Other claims dropped out before the fair use stage because they were uploaded to the e-reserves system but never downloaded by students. The court dismisses these from the lawsuit as de minimis, explaining that these uses by the University, while technical implicating the copyright owners’ exclusive rights, don’t affect the incentives for authors to create. This puts more teeth in the de minimis doctrine in copyright: it goes beyond the view that de minimis means “not substantially similar.” It also strengthens the argument that “internal use” copies never used to reach to an audience that reads them for their content don’t infringe. Think, for example, of the HathiTrust’s archive of scans from Google Books.

Anyone know why this reasoning wouldn't justify the jury's finding about the test files as de minimis, since they never shipped with Android and so no user ever used them?

Update 4: Here's the final report from Zach, on Oracle's rebuttal testimony:

Dr. Mitchell, recalled.

Oracle: On Friday, we asked Dr. August about the difference between your positions on symbolic references. Did he fairly characterize your opinion?

Dr. Mitchell: No.

Oracle: So he was saying that you were trying to get “fun” or “y” over here into the instruction, is that what you’re trying to do?

Dr. Mitchell: No it’s perfectly happy right where it is.

Oracle: Do Dalvik instructions contain symbolic references?

Dr. Mitchell: Yes.

Dr. Mitchell: What are they?

Dr. Mitchell: The field indexes.

Oracle: But those are numbers, does it matter?

Dr. Mitchell: Not at all, a number can be a symbolic reference.

Oracle: What about the claim construction that says a number can’t be a symbolic reference?

Dr. Mitchell: Nothing. A number is a perfectly good name. Adding the dex file to the poster. It includes the instructions, list of opcodes and operands, but not the resolve field table.

Oracle: Is the field index in a Dalvik instruction a symbolic reference?

Dr. Mitchell: It is, according to the court’s construction. It is a reference and it identifies data. It is a name (01) and that name is not a numeric memory location for the data (if it were, we wouldn’t have to resolve it) and it is resolved dynamically rather than statically.

Oracle: What’s the issue with resolve.c with respect to the ‘104 patent?

Dr. Mitchell: The only issue is whether the field references are symbolic references are not. And that just turns on what we mean by data.

[Oracle: Gets a poster that shows a dex file and some portion of a resolution process, describes resolve.c. Asks Dr. Mitchell to revise it.]

Dr. Mitchell: Describes “data” as the “constant pool” and separates the resolved fields table since it is created in memory at runtime by the Dalvik VM, not in the dex file. Constant pool comes from the source code. Source -> java bytecode (which has constant pools) -> dx tool (reformats constant pools)

Writes an example that uses regular high school geometry. Mitchell: “I don’t know if you enjoyed high school geometry or not. I happen to, but that’s just me.” [Doesn’t look like the jury was so fond of it]

So we’re drawing points with x and y coordinates, the type of each is a byte. [Draws two fields]. To do something, I write a method movingUp()

[ed: we can’t actually see what he’s writing from the gallery].

It looks like y=y+1. So this class has two fields and one method that uses one of the fields. The instance field y is used here and the program has to get its value in order to add 1 to it. So this particular part of it is turned into some iget, say iget field@01. Field@01 is really the Dalvik instruction’s version of y. That 01 is a symbolic reference. It needs to be resolved in order to execute the iget instruction, have to find where the actual data is in the object.

Oracle: So what does the Dalvik VM do with the memory location after determining it?

Dr. Mitchell: It obtains the data according to this numeric references. The next time this instruction is executed, the VM looks in this table and doesn’t need to do the search process again. This works for this instruction and any other one with the symbolic reference field@01.

Back to the definition of symbolic reference. Dynamic is not disputed for resolve.c. Dr. Mitchell writes the definition out even though it’s on all our screens. Shows the name is 01. Memory location is 48. 01 not equal to 48. Therefore he says it is a symbolic reference, not a numeric reference.

Oracle: And how does this happen in dexopt?

Dr. Mitchell: Basically the same. The difference is that the I get instruction is rewritten and the symbolic name is written to a numeric reference. So iget is rewritten to igetquick and the 01 is changed to the memory location. But all the references have the same meaning whether dexopt runs or not.

Oracle: Does dexopt run dynamically?

Dr. Mitchell: Yes. It is the dynamic process of searching through these references and as a portion of the Dalvik VM. It resolves the location of classes loaded into memory at run-time. It’s all dependent on information known at runtime and not known independent of the platform of the code. I don’t have anything against Dr. August, but if I could not share his water glass, that would be good…

Alsup says we’re trying to economize.

On to the ‘520 patent.

Dr. Mitchell: He says the dx tool simulates bytecode. Something can be pattern matching as a portion of simulation.

Dr. Mitchell: As I read the code, the process is simulation.

Oracle: Andriod has no stack operations. What’s the relevance?

Dr. Mitchell: I don’t see why a stack is required for a simulation. A simulation isn’t true execution of a program. I believe the ‘520 patent is infringed because the implementation of the dx tool meets all the limitations of the claims.

Google’s Cross-Examination of Dr. Mitchell, Robert Van Nest questioning:

Google: Between your first report and your second report, you had access to additional information?

Dr. Mitchell: Yes.

Google: Before you wrote your reply report, you had access to all of Dr. August’s opinions?

Dr. Mitchell: No.

Google: But you had his report, reviewed it, and so this second report was written only after you reviewed Dr. August’s report?

Dr. Mitchell: Yes.

Google: You’ve previously said that this operand is in the instructions?

Dr. Mitchell: Yes.

Google: And you identified that operand as an index?

Dr. Mitchell: Yes, a field index.

Google: So an index into the field table shown here on the slide?

Dr. Mitchell: Yes, a simplified version.

Google: And it’s a reference to a location in the field table?

Dr. Mitchell: It’s an index into that array, yes.

Google: And a class index is an index into a table, works much the same way?

Dr. Mitchell: Yes.

Google: And a method index, also an index into a method table, works much the same way?

Dr. Mitchell: Yes.

Google: And the string index…

Dr. Mitchell: Yes.

Google: In your first report, you repeatedly referred to these indexes as numerical references?

Dr. Mitchell: The only place I can think of where that is in the paragraph that, as I explained, it contained an error, which I corrected.

Google: Have you gone back through your report over the weekend and looked to see whether you referred to these as numerical references?

Dr. Mitchell: No.

Puts up part of Dr. Mitchell’s first report. Shows a couple of sections that say “numerical references” and “method indexes”.

Google: So that’s two places where you looked at the Dalvik bytecode instructions and called it a numerical reference?

Dr. Mitchell: Yes.

Google: Is that also a mistake?

Dr. Mitchell: No.

Google: [Shows another place where it says “numerical reference string_idx.”] Almost every time you saw an index like these in the Dalvik instructions, you called it a numerical reference?

Dr. Mitchell: I don’t recall that.

Goes to paragraph 284, another reference to a field id with a specified index as a numerical reference. Dr. Mitchell says it’s something different. ID and idx [meaning index] are two different things. Apparently he meant a field id with a specified index; arguably the report is missing a comma.

Google: Can you think of any example in your report where you call an index anything other than a numerical reference?

Dr. Mitchell: I believe there are some paragraphs that do that.

Google: And your second report and your testimony last week and this week are only after you had the opportunity to review Dr. August’s report?

Dr. Mitchell: No, that’s not my recollection.

[We get into a kind of ridiculous circle of questions looking at the example. test1=”Hello World” is compiled to Java bytecode and then into Dalvik bytecode, but the references to “test1” in the bytecode are just comments, used for debugging. The executable bytecode itself doesn’t say “test1.” The comments say “test1” so that developers can use the same name when testing/debugging their code. Van Nest doesn’t understand this.

[15 minute break]

Judge Alsup before the jury comes in: “We’ve got to finish this today.” Van Nest says he’s on track for the same thing. [Chuckles all around.]

[Jury’s back]

Google is still cross-examining Dr. Mitchell:

Found another spot in his first report that says “numerical reference.” (e.g., it says “numerical reference (method id with specified index)”) Arguing over the exact intent. Dr. Mitchell keeps saying that’s not what he meant, but agrees that it could be read that way.

Looking at the ‘520 patent, claim 1.

Google: Fair to characterize the executable code as pattern matching?

Dr. Mitchell: Not exactly.

Google: There are patterns that appear in the dex bytecode that is analyzed?

Dr. Mitchell: There is a repeating pattern of four instructions.

[Shows the Java bytecode for those four instructions. Dr. Mitchell argues that they aren’t a repeating pattern.]

Google shows the next four lines and they are the same, just the arguments incremented by one. It repeats another few times just in this slide.

Google: Could this be analyzed using pattern matching?

Dr. Mitchell: Potentially.

Google: In a Java bytecode system, instructions operate by manipulating the stack?

Dr. Mitchell: Yes.

Google: And in the dx tool, there is a simulator file that you’ve spent a lot of time talking about. This set of code does refer to “getting the stack,” correct?

Dr. Mitchell: Yes.

Google: parseNewArray() is a different set of code from the simulator class? Different code in a different file?

Dr. Mitchell: Yes.

Google: And in the executable source code, not in any comments, of parseNewArray(), there are no references to getting a stack or popping or pushing or anything like that?

Dr. Mitchell: I don’t see it, no.

Google: Have you been able to determine whether any other file in the dx tool calls the parseNewArray() method?

Dr. Mitchell: I didn’t see that as important to look into.

Google: So you can’t tell us if any other classes that don’t have anything to do with simulation call that code?

Dr. Mitchell: I didn’t look into that.

Oracle’s redirect of Dr. Mitchell:
Oracle: You were asked about the errors in your report. Let’s turn to Vol. 2, Exhibit A of the opening report, overview section (p. 38). What were you citing here to make your point about symbolic references?

Dr. Mitchell: This citation is to a source code file called reduceConstants.c, and at the beginning of that file is a description. I believe Mr. McFadden wrote this. It talks about the indexes and invoke_virtual_instruction, which is similar to the iget with a symbolic reference.

Oracle: What does this say about a symbolic vs dynamic reference?

Dr. Mitchell: This explains clearly that these indexes are symbolic references.

Now to Vol. 1, paragraph 283: “Next the function…determines or resolves symbolic references (instance fields) in numerical references…”

Paragraph 252: Also completely in-line and similar to what Dr. Mitchell was saying earlier today. Optimize.c resolves the field index in the constant pool to a byte offset

Paragraph 250: Calls the process a resolution of a symbolic reference. Written well before seeing Dr. August’s report.

Dr. Mitchell done.

Oracle rests its rebuttal case. Google huddle time. Google rests.

Judge Alsup: We have reached another milestone, which means no more evidence. Jury can use everything they learned in the first phase as well. Too late for closing arguments. 1:15 hour per side for closing arguments, will probably go to the jury sometime between 11-noon. No deliberations or talking about the case in the meantime.

[Jury dismissed]

Oracle asking about a Rule 50 motion (judgment as a matter of law). Outline to be submitted tomorrow morning, briefs due 5pm on the 16th, oppositions at 5pm on the 17th for both sides. Van Nest may want more time and the 18th is ok if he needs it.

Clerk hands out new jury instructions to reflect the stipulation on indirect infringement. Now no references to “direct infringement,” just “infringement.”

Judge asks for parties to come back at 1pm for a last chance to point out anything they want changed. Does not want to rehash and reargue things that have already been beaten to death. Accept your loss with good grace.

[PJ: That's Greek to Boies Schiller, from all we've seen. It reminds me of the Magistrate Judge in SCO v. IBM asking both sides to play fair, as in football, according to the rules.]

Other preparations for the jury, getting exhibits indexed and organized. Judge says the last time deliberations took quite a bit longer than I thought it might, but we don’t know. Could be 20 minutes or could be a week.

Judge reminds the lawyers to knock it off with the numerous “I think” and “I believe” statements in the closings that both parties used last time.

Oracle says that the jury was told some things about indirect infringement in openings, wants the judge to tell them it doesn’t apply. Parties to agree on a single sentence on that for the judge to read. Van Nest jokes that they’ll congratulate the lawyers for their hard work.

Oracle has about 40 minutes left, while Google has more than two hours.

[I didn’t stay for the 1 pm session to finalize the jury instructions, but journalists on Twitter indicate it was pretty quick and simple.]

We'll post those documents in a bit.

Update 5: All the trial exhibits are now available as PDFs here. Some are also done as text. Look for the date nearest the day, as they are listed by the date they were entered, which could be a day or so after the date of their use in the courtroom.

  View Printable Version

Groklaw © Copyright 2003-2013 Pamela Jones.
All trademarks and copyrights on this page are owned by their respective owners.
Comments are owned by the individual posters.

PJ's articles are licensed under a Creative Commons License. ( Details )