|
|
|
| Authored by: Anonymous on Sunday, May 13 2012 @ 12:06 AM EDT |
No, now you're talking indirection. We call that a REFERENCE. A SYMBOLIC
reference means it involves resolving a SYMBOL, not jumping to a memory
location.
Ugh. Non-coders, Please. To an individual ordinarily skilled in the art, this
interpretation would not be consistent with the patent claim.
"A numerical index into a table of field definitions is arguably not the
numeric memory location of the data itself"
You are wrong, you just don't know it. You just said: It's not as if one plus
one is MUST be two -- But we're talking integers, not statistics, so yes, it
must be two.
Symbolic reference means there is a symbol table involved, not a MEMORY ADDRESS
+ N BYTES, which is what an INDEX is. They can not mean References (Indexes and
Pointers) as well as Symbolic References with the term "symbolic
reference" -- It's like saying: Well, they said MALE, but a Male is a
Human, and a Female is a Human too, AND has the word "Male" in the
word feMALE, so the medicine that is designated as for use in "males
only" should be banned because it causes adverse affects in females. I
mean, you don't get specific and say SYMBOLIC REFERENCE if you mean ANY
REFERENCE.
"Well, this patent applies to Virtual Machines, and there's no way to prove
we're NOT living in the matrix, so everything is Virtual, and this hand crank
thus infringes our virtual machine patent" The rabbit hole you've started
down is very deep.
Without getting into the broadening of "dynamically" to mean
"Before the program ever runs" (which is not what that means to an
individual ordinarily skilled in the art, to which the patent must be clear and
understandable), the interpretation would VASTLY broaden the patent to cover C
programs using pointer arithmetic.
The CPU itself may cache such computations (MEM_POS + 10 * ELEMENT_SIZE) and
next time it sees that instruction, dynamically replace the calculation. Chips
do a lot of optimization that the coder and language architect have no control
over. This would mean it would be impossible to write a program AT ALL without
infringing the patent.
If Oracle wants to broaden it that far, then we need to re-re-evaluate the
patent and consider the foundations of computer science, as prior art. In
machine code the idea of data Pointing to other data (indirection) is
foundational, and is never considered as a "symbolic reference" -- You
might as well just pick the term "memory location" and broaden that to
mean inside dead peoples brains, then go exhume and sue them to un-death.[ Reply to This | Parent | # ]
|
| |
| Authored by: Anonymous on Sunday, May 13 2012 @ 01:39 AM EDT |
a symbolic reference is 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
Key here, aside from dynamically vs statically (which is only a matter of when
you perform certain compilation steps), is that numbers aren't names. Davlik
only refers to the data by way of numeric memory locations, even though they are
sometimes given in terms of offsets in relation to other memory locations.
The names that ARE in the Davlik bytecode are referred to by the memory
addresses, not the other way around. The names are reached by way of offsetting
into memory -- Here we're saying: This data field that's already been resolved
used to be named the name represented by the memory stored 12 bytes from the
start of the memory address of the object. You go 12 bytes and find some text,
like "Fornslog", that's not resolution ("resolved"). That's
not "data that is named", that is data referring to it's own name, not
a name referring to data.
Take that name "Fornslog". By itself it may stand for an ARBITRARY
memory location, then it is a symbolic reference -- It refers to data by a name
other than by memory address.
To find out where the data that Fornslog refers to the memory address must be
resolved -- It must be stored elsewhere, and looked up. The memory address is
not anywhere in the name itself. The actual memory address is typically stored
in a "symbol table" or other structure that maps names to addresses.
"The data at a position 8 bytes beyond this address" That's not a
name. It is not arbitrary. Your own name is an arbitrary designation given to
stand in for "the person with the following DNA sequence: ACT GTA
CGA..."
Your name does not relate to any arbitrary person such as: "The 8th person
in a given line." If the line changes, then you're referring to a different
person, or maybe the same person if everyone files into the next line by chance.
However, it's not dependent on the names of the people in the line. The
"memory 8 bytes beyond a given memory address" is not a name anymore
than "the 8th person in a line of people" is a name.
Furthermore, if you do manage to define the bytecode reference "memory
address + offset from the memory address" as being a symbolic name, then
the symbolic name does not match the rest of the claim, given that "a
reference that identifies data by a name other than the numeric memory location
of the data" does not hold true: The "name" would be a reference
that identifies data by ONLY the numeric memory locations of the data.
[ Reply to This | Parent | # ]
|
| |
| Authored by: bugstomper on Sunday, May 13 2012 @ 04:45 AM EDT |
In the court order that specified the claim construction you quoted (filing
#137) Judge Alsup explained his reasoning for the construction. Notice that it
says "that identifies data by a _name_ other than the numeric memory
location of the data". He removed Google's construction about it being
necessarily string or character based, but he did leave in the distinction
between symbolic references that are based on names and numeric references that
are based on the numeric address of data.
Nobody brought up the issue of indirect references. The only distinction is
between symbolic (or references by name) and numeric (references by a numeric
address). In the absence of it being brought up by either side, Judge Alsup
would not have known about the possibility of an indirect addressing. The patent
itself does not mention it. Figure 8 in the patent illustrates a symbolic
reference using an instruction LOAD "y" that loads data from memory
location 2 that is named "yt", and shows it being replaced with the
instruction LOAD 2.
David August took a literal approach to the patent in pointing out that Dalvik
byte code instructions have nothing of the form LOAD "y" that could be
used as described in the patent.
On the other hand, the Java VM interpreter does dynamically resolve instructions
that contain in their operand an index into the constant pool of a symbolic
name, replacing them with an instruction that has a numeric reference. It would
make sense to consider a LOAD_INDIRECT_SYM 5 that looks up data at memory
location or offset 5 to find the name "y" and then resolve the
symbolic reference "y" to numeric location 2 and replaces the
instruction with LOAD 2 as practicing the claims of the patent.
But even without being as literal as David August was in interpreting the
claims, Dalvik still does not have instructions that do that. The iget
instructions that have a field@CCCC operand that "are reasonable candidates
for static linking" are only candidates for changing an indirect numeric
reference into a direct numeric reference, not for symbolic reference
resolution.
In addition, Judge Alsup made very clear in the same order regarding claims
construction that the patent was only talking about dynamic as opposed to static
resolution. There are no iget instructions that can contain symbolic references
that can be interpreted dynamically even in non-quickened form.
[ Reply to This | Parent | # ]
|
|
|
|
|
