Datasets:

Infi-MM

/

InfiMM-WebMath-40B

like 49

Follow

InfiMM 16

[ "", null, "# Parallel Elements\n\n## Introduction\n\nTwo or more components are considered to be in parallel if their “leading” and “trailing” terminals are electrically connected. Because of this electrical connection, the components will have the same voltage across them. Thus, sometimes people will simply say that parallel components are components that have the same voltage across them. While this is true, this statement doesn't completely define what parallel means, because two components may be in different parts of a circuit and yet have the same voltage drop across them. Despite having the same voltage drop, if they aren't directly electrically connected, we would not say they are in parallel.\n\nFigure 1 shows a circuit in which all the components are in parallel. In this case a 3.3V voltage source is in parallel with two resistors, $R_1$ and $R_2$. Because all these components are in parallel, one might say $R_1$ is in parallel with the voltage source, $R_1$ is in parallel with $R_2$, $R_2$ is in parallel with the voltage source, or, of course, all these components are in parallel. Keep in mind that the type of source that is present in the circuit is immaterial—all that matters in order for components to be in parallel is that their terminals are electrically connected.", null, "Figure 1. Circuit in which all of the components are in parallel.\n\nWhen a schematic has components drawn in parallel, it's usually easy to recognize that they are electrically parallel, too. However, the orientation of components in the schematic has nothing to do with whether or not the components are (electrically) in parallel. For example, in Fig. 2, the resistors $R_1$ and $R_2$ are said to be in parallel and the same voltage appears across them. This circuit is, in fact, identical to the circuit of Fig. 1 despite being drawn slightly differently.", null, "Figure 2. The orientation of components in a schematic does not depend on whether or not the components are (electrically) in parallel. $R_1$ and $R_2$ are in parallel in this circuit.\n\nThe circuit of Fig. 3 has three resistors in parallel: $R_2$, $R_3$, and $R_4$. The voltage source and $R_1$ are not in parallel with these resistors.\n\nIn the circuit shown in Fig. 4, no two resistors are in parallel. However the voltage that appears across $R_1$ is the same as the voltage that appears across the combination of $R_2$ and $R_3$. The resistors $R_2$ and $R_3$ are in series because the same current passes through each of them. Thus, one might say that “$R_1$ is in parallel with the series resistors $R_2$ and $R_3$.” As discussed in the link available at the box to the right, series resistors can be combined to form a single equivalent resistance. Thus $R_1$ can be described as being in parallel with this equivalent resistance.", null, "Figure 4. The orientation of components in a schematic does not depend on whether or not the components are (electrically) in parallel. $R_1$ and $R_2$ are in parallel in this circuit.\n\n## Parallel Resistors\n\nWhen resistors are in parallel, the resistors can be replaced with a single equivalent resistor. Insofar as the rest of the circuit is concerned, there would be no difference between the parallel resistors or the single equivalent resistor. To illustrate how we obtained the equivalent resistance, consider the two parallel resistors, $R_1$ and $R_2$, shown in the circuit on the left of Fig. 5. In Fig. 5, a voltage source supplies the power but the voltage source is not explicitly shown. Instead, we show ground at the bottom and, at the top of the circuit, the voltage $V$ that the source produces. It is understood that there is a path for current to flow from ground, through the source, and back to the top of the circuit.", null, "Figure 5. The parallel resistor on the left can be replaced with a single equivalent resistor as shown on the right.\n\nLet $I_1$ be the current through $R_1$ and $I_2$ be the current through $R_2$. Given that both resistors have the same voltage $V$ across them, we can use Ohm's Law to calculate the currents:\n\n$\\begin{array}{l}{I_1} = \\frac{V}{{{R_1}}},\\\\{I_2} = \\frac{V}{{{R_2}}}.\\end{array}$\n\nAdding these currents, we get the total current into the two resistors, $I_{\\mathrm{tot}}$. This current is given by:\n\n${I_{{\\rm{tot}}}} = {I_1} + {I_2} = V\\left( {\\frac{1}{{{R_1}}} + \\frac{1}{{{R_2}}}} \\right).$\n\nBecause we know from Ohm's Law that current is given by voltage divided by resistance, we can think of the total current as being given by $I_{\\mathrm{tot}} = V / R_{\\mathrm{eq}}$ where $R_{\\mathrm{eq}}$ is the equivalent resistance. Equating this expression with the equation above, we can write that the equivalent resistance is given by\n\n$\\frac{1}{{{R_{{\\rm{eq}}}}}} = \\frac{1}{{{R_1}}} + \\frac{1}{{{R_2}}}.$\n\nOr, rearranging slightly (i.e., taking the inverse of both sides), we can write:\n\n${R_{{\\rm{eq}}}} = \\frac{1}{{\\frac{1}{{{R_1}}} + \\frac{1}{{{R_2}}}}}.$\n\nThis analysis can be extended to any number of parallel resistors. For $N$ parallel resistors, the equivalent resistance is given by\n\n${R_{{\\rm{eq}}}} = \\frac{1}{{\\frac{1}{{{R_1}}} + \\frac{1}{{{R_2}}} + \\cdots + \\frac{1}{{{R_N}}}}}.$\n\nTo find the equivalent resistance for two parallel resistors, using a bit of algebra, you can show that the equivalent resistance is given by the product of the resistances over their sum, i.e.,\n\n${R_{{\\rm{eq}}}} = \\frac{{{R_1}{R_2}}}{{{R_1} + {R_2}}}.$\n\nKeep in mind that this product-over-sum formula only works for two resistors. Another thing to keep in mind is that no matter how many parallel resistors there are, the equivalent resistance must always be less than the smallest individual resistance.\n\n## Important Points\n\n• Parallel components' terminals are electrically connected to each other.\n• Because their terminals are in contact, components that are in parallel always have the same voltage across them.\n• Parallel resistors can be combined to form a single equivalent resistor.\n• The equivalent resistance is always less than the smallest individual parallel resistor." ]

[ null, "https://learn.digilentinc.com/images/Digilent-Logo.png", null, "https://learn.digilentinc.com/Documents/Topics/cK-electric/parallel-elements/par1.svg", null, "https://learn.digilentinc.com/Documents/Topics/cK-electric/parallel-elements/par1.svg", null, "https://learn.digilentinc.com/Documents/Topics/cK-electric/parallel-elements/parallel3.svg", null, "https://learn.digilentinc.com/Documents/Topics/cK-electric/parallel-elements/par2.svg", null ]

[ "(function (a, d, o, r, i, c, u, p, w, m) { m = d.getElementsByTagName(o), a[c] = a[c] || {}, a[c].trigger = a[c].trigger || function () { (a[c].trigger.arg = a[c].trigger.arg || []).push(arguments)}, a[c].on = a[c].on || function () {(a[c].on.arg = a[c].on.arg || []).push(arguments)}, a[c].off = a[c].off || function () {(a[c].off.arg = a[c].off.arg || []).push(arguments) }, w = d.createElement(o), w.id = i, w.src = r, w.async = 1, w.setAttribute(p, u), m.parentNode.insertBefore(w, m), w = null} )(window, document, \"script\", \"https://95662602.adoric-om.com/adoric.js\", \"Adoric_Script\", \"adoric\",\"9cc40a7455aa779b8031bd738f77ccf1\", \"data-key\");\nvar domain=window.location.hostname; var params_totm = \"\"; (new URLSearchParams(window.location.search)).forEach(function(value, key) {if (key.startsWith('totm')) { params_totm = params_totm +\"&\"+key.replace('totm','')+\"=\"+value}}); var rand=Math.floor(10*Math.random()); var script=document.createElement(\"script\"); script.src=`https://stag-core.tfla.xyz/pre_onetag?pub_id=34&domain=\\${domain}&rand=\\${rand}&min_ugl=0\\${params_totm}`; document.head.append(script);" ]

[ null ]

[ "# IonicWind Software\n\n## Creative Basic => General Questions => Topic started by: GWS on May 13, 2013, 02:00:43 am\n\nTitle: Rounding to an Arbitrary number of Significant Digits.\nPost by: GWS on May 13, 2013, 02:00:43 am\nHi,\n\nHere's a little problem I came across while working on a current project - how to round a number to a given number of significant digits.\n\nThat should be easy, I thought.  For example I wanted a number like 12.1257 to return 12.1\n\nAfter screwing my brains into a knot, I got some clunky code working (which I won't for shame reveal), except to say, it involved a lot of string handling of the Val() to Str\\$() to Val() type. ::)\n\nHow difficult could a simple operation be?\n\nFortunately, my daughter is an expert Googler, found this discussion in some java - C hieroglyphics, which I think I've managed to translate into the much easier to read Basic code.\n\nAnyway, here's the test program I've concocted, to take any positive, non-zero number, and re-map it to a given number of significant figures.  I was interested in 2 or 3 figures for my application. :)\n\nCode Select\n`' Rounding to a given number of significant figures ..' GWS - 2013openconsoleclsautodefine = \"off\"setprecision 5def n:intdef x,r:doubledeclare Round(value:double,nfigs:int)' some test values ..x = 12.1257'x = 4855600'x = 2008'x = 0.0681'x = .55578'x = 1.50666'x = 27460'x = 635.89r = Round(x,3)print \"rounded = \",rdo:until inkey\\$<>\"\"closeconsoleendsub Round(value,nfigs)def ret,d:double' routine to round a value to 'n' significant figures .. if (value = 0) ret = 0 else d = ceil(log10(value)) n = -(d - nfigs) ret = int(value * 10^n + 0.5) * 10^-n endifreturn ret`\n\nLook at that lovely little subroutine - is that smart or what?\nI'm still not sure I understand how it does it - but it works!  ;D\n\nhttp://stackoverflow.com/questions/202302/rounding-to-an-arbitrary-number-of-significant-digits (http://stackoverflow.com/questions/202302/rounding-to-an-arbitrary-number-of-significant-digits)\n\nAll the best, :)\n\nGraham\nTitle: Re: Rounding to an Arbitrary number of Significant Digits.\nPost by: Kian on May 13, 2013, 12:55:39 pm\nHi Graham,\n\nQuoteI'm still not sure I understand how it does it\n\nCode Select\n`if (value = 0)`\nThis ensures that '0' is not passed to the logarithm function as log(0) is undefined.\n\nCode Select\n`d = ceil(log10(value))`\nThis returns how many digits there are before the decimal point, using the 'ceil' function to ensure rounding up.\n(e.g. log(12.345) is 1.0914911 because it is between 10^1 and 10^2, and this is rounded up to 2)\nValues below zero give a negative result for this.\n\nCode Select\n`n = -(d - nfigs)`\n('nfigs-d' would probably save a cycle or two)\nThis calculates how many columns to shift the digits for the purposes of rounding.\n(e.g. to find 12.345 to 3 s.f. it should be shifted 1 column to the left to round after the 3)\n\nCode Select\n`ret = int(value * 10^n + 0.5) * 10^-n`\nThe 'value * 10^n' performs the shift, i.e. turns 12.345 into 123.45\nand the 0.5 is added to ensure that the 'int' function rounds anything from .5 and higher upwards.(leaving 123 in the above example)\n\nFinally, the '* 10^-n' reverses the shift.(leaving 12.3 above)\n\nRather long-winded, but as concise an explanation as I can manage at this time of night.\n\nKian\nTitle: Re: Rounding to an Arbitrary number of Significant Digits.\nPost by: GWS on May 13, 2013, 04:56:36 pm\nThanks Kian,  ;D .. that's a great explanation.\n\nYou're right - I should have spotted the double negative ..  'nfigs-d' is much neater  :)\n\nI like that little subroutine - it does all the work in 3 lines, where my sledgehammer method was taking more than a page of code. ::)\n\nAll the best, :)\n\nGraham" ]

[ null ]

[ "Lemma 20.28.2. Let $f : X \\to Y$ and $g : Y \\to Z$ be morphisms of ringed spaces. Then $Rg_* \\circ Rf_* = R(g \\circ f)_*$ as functors $D(\\mathcal{O}_ X) \\to D(\\mathcal{O}_ Z)$.\n\nProof. By Lemma 20.28.1 we see that $Rg_* \\circ Rf_*$ is adjoint to $Lf^* \\circ Lg^*$. We have $Lf^* \\circ Lg^* = L(g \\circ f)^*$ by Lemma 20.27.2 and hence by uniqueness of adjoint functors we have $Rg_* \\circ Rf_* = R(g \\circ f)_*$. $\\square$\n\nIn your comment you can use Markdown and LaTeX style mathematics (enclose it like $\\pi$). A preview option is available if you wish to see how it works out (just click on the eye in the toolbar)." ]

[ null ]

[ "# Why is laser light a cone?\n\nWhat about the production of laser light disallows it to be perfectly straight as opposed to a cone? I feel like it should be a plane wave, not a very tight cone.\n\n• Can anything man-made be \"perfectly\" anything? – tpg2114 Jul 16 '13 at 2:53\n• See also my description (physics.stackexchange.com/a/70394/26076) of diffraction. A non diverging plane wave has infinite sideways extent. You only have a finite output aperture for a laser, although you can make it very big. – WetSavannaAnimal Jul 16 '13 at 3:19\n• Why can't you just have the source be some flat surface? (I don't really know how lasers work.) I mean, what if you just have some small flat surface that emits light-would that then be a plane wave-even though it isn't an infinite plane source? – user24082 Jul 16 '13 at 5:37\n• Because Christian Huygens wanted it to be a cone :=) – Georg Jul 16 '13 at 11:24\n• You can make the source a big flat surface as you say. But the bigger you make it (and it has to be optically perfect to well within $\\lambda /10$) the harder and costlier it is to do. The beam width is also set by the gain medium - if this isn't a gas, then this is hard to make wide too. It comes down to technology limitations, and you'll never get the aperture to be infinite, so there'll always be some divergence. – WetSavannaAnimal Jul 16 '13 at 11:45\n\nPlane waves are an idealization and can never be achieved in the real world because they must have an infinite spatial extent (and thus carry infinite energy) to work. A truncated plane wave is not a solution to the wave equation. The feature that real lasers have that forces them to have nonzero angular divergence is a finite spatial extent. Like all finite-size wave sources, their output will diffract.\n\nThis spatial extent will usually be a few millimeters, which is about 10,000 times the wavelength (of about a few tenths of a micron). This means that the beams can have angular divergences as low as ~1 milliradian, which they are very close to: over 10 m, the beam has to diffract to at least 1 cm, and it usually isn't bigger than that. Thus even cheap laser pointers are usually pretty close to 'as good as it gets' as regards angular divergence.\n\n• So, holding wavelength constant, the wider the aperture of the laser cavity the lower the angular divergence of the beam? – feetwet Jul 25 '14 at 22:21\n• That is sort of correct. A wider cavity aperture enables a smaller divergence, but it does not guarantee it. The focusing needs to be right, and the laser needs to be clean enough for it to work. Once your divergence is diffraction-limited, though, only a wider aperture can save you. – Emilio Pisanty Jul 25 '14 at 23:35\n\nWell a laser source appears to be an \"artificial star\" ; a diffraction limited source of some small but not zero extent. For example something like a He-Ne gas laser appears to be a source about the diameter of the glowing gas discharge that you see in the tube. The larger that apparent source is the smaller is the angular divergence of the beam. The smaller the source minimum size, the larger is the beam divergence. At the narrowest point of the beam -- the beam waist -- the wavefronts are planar. As you go further from the waist, however, the wavefronts become approximately spherical, and at large distances they are quite spherical.\n\nSmall lasers like solid state diode lasers have a very small beam waist, so they have very large divergence-cone angles of many degrees. However, a good clean laser beam can be focused to a fractional wavelength sized spot. Generally the spot will be a clean circle with no surrounding rings, because the beam has a Gaussian intensity cross-section profile, so the beam tapers to zero at the outer edge. It is common practice to use laser optics having a clear aperture of about 1.5 times the diameter where the beam drops to $1/e^2$ of its central intensity. If you crop the beam optics tighter than that so the lens rim has significant beam intensity, then you will get diffraction rings, and the beam quality will degrade. There are standard textbooks, that describe the profiles both laterally and longitudinally for various laser resonator cavity configurations.\n\nIt is possible, with a lens, to convert the laser beam mode into a converging beam, so that the beam waist is well outside the laser and you get the smallest possible spot at some distance. The further away that is, the longer will be the distance over which the beam remains almost parallel.\n\n• Following the last paragraph of this answer (and returning to the original question): So can you focus the laser at infinity so that the beam has no divergence? And boy would I love some diagrams to illustrate this answer.... – feetwet Jul 25 '14 at 22:16\n\nLaser light is collimated because the resonant cavity used in (most) lasers has two parallel mirrors at either end. Light makes many trips between the two mirrors so any light that isn't closely parallel to the axis of the cavity hits the side of the cavity and is absorbed. Only light closely parallel to the axis survives to emerge from the laser.\n\nActually the mirrors are not exactly parallel. They are normally slightly concave for technical reasons I've never fully understood. However the deviation from a plane is so small that the beam divergence is typically less than a milliradian.\n\nAs George says in his answer, the beam will diverge due to diffraction. I calculated this in my answer to Lasers and Collimation. The divergence due to diffraction is also typically under a milliradian.\n\nFirst the suggestion that a plane wave must be infinite in extent. Well I suppose that is pedantically correct, even if the wave intensity at the periphery is 10^-(Avogadro's number).\n\nBut a single mode fundamental laser mode has a Gaussian intensity beam profile, so the wave amplitude diminishes rapidly with radius, and at the propagating beam waist the wave is exactly plane but essentially zero amplitude at the extreme edge.\n\nNow the parallel mirrors idea. If you have two exactly plane parallel mirrors optically flat to say 1/100th wavelength, and a collimated parallel beam can be generated inside the cavity perpendicular to those ideal mirrors, the beam will bounce back and forth indefinitely.\n\nBut suppose the mirrors are not exactly parallel, but have a slight wedge angle, say 10^-100 arc seconds. Well because of that wedge angle, the beam will translate sideways, that tiny angle times the round trip length. So the beam eventually walks off the edge of the mirrors.\n\nSo two plane parallel mirrors is an unstable resonator. The beam cannot live inside that cavity. There are actually an infinite number of end mirror configurations, and these can be plotted on a graph of C1 versus C2 where C is the mirror curvature. We optical design types do NOT like radii of curvature. It is some little nit picky thing like my laptop keyboard does not have an infinity key to use for the radius of curvature of a plane surface. And in imaging lens situations it is 1/r or c which determines the focusing effect, and curvature (powers) just add algebraically. So mathematically we deal in curvatures.\n\nA very common stable laser resonant cavity, is a single plane mirror, plus a single concave mirror. The mirror radius of curvature is twice the mirror separation. Actually, this is just half of a \"confocal\" cavity, where two spherical mirrors each have their center of curvature on the opposite mirror.\n\nNow just think about that. Any line from the center of curvature, is a radius of the sphere, and many such radii, will hit the other spherical mirror. Now one of those radii, will hit the spot on the second mirror, where the center of the first mirror is.\n\nSo it can be seen that the single line joining the centers of curvature of the two mirrors, is a radius of both of them; it is a perfect axis of symmetry. Now a few sketches will convince that the two mirror radii, don't need to be exactly equal. The cavity is quite stable against practical manufacturing tolerances. Well in the confocal resonator, you have spherical wave fronts on each mirror, and exactly half way between, is the smaller planar beam waist.\n\nSo hell, why not put a plane mirror there, and dispense with half of the cavity length.\n\nAnd yes, there will be a normal to the plane mirror that passes through the center of curvature of the one spherical mirror, and therefore is a radius. So the half confocal cavity is a very popular choice, and most He-Ne lasers are built that way. That plane mirror with its smaller beam waist is pretty much always the output mirror, so it has less than 100% reflectance, to let some beam leak out. The back spherical mirror can be 100% reflecting, or you can leak a small back beam, that you can sense, as an amplitude feedback signal to regulate the laser beam power.\n\nThe beam divergence is not dependent on the radius of the curved mirror, it is the diffraction limited spread of the beam depending on the diameter of the ;lasing \"gain medium\". longer tube lengths will result in narrower laser line widths, which also affects the divergence. I'm writing this all from memory, so I would have to dig out some text books to get you the design math; but I suspect that Wiki or some other site would have more details on the resonator stability diagram.\n\nAnna V understands all this beam stability stuff, because the exact same optical beam confinement problems occur in particle accelerators. A circular path in a uniform transverse magnetic field, is also unstable as Anna knows, so your particles will all crash into the walls, if you don't design a stable resonant cavity for your circulating particle beam. so you have to have magnetic lenses with alternating gradients and all kinds of trickery.\n\n• I'm not sure the \"infinite plane wave\" thing is just pedantry - it's a hopefully simpler way of talking about what happens when you look at the field in momentum space: there will always be a spread of plane wave directions in a wave superposition, thus a tendency to diverge, unless the wave has infinite sideways extent. The Gaussian mode also has a nonzero spread of angles (even though it saturates the Heisenberg inequality). The fundamental issue is that a function and its Fourier transform cannot both have compact support - this is a real and inescapable fact. – WetSavannaAnimal Jul 17 '13 at 2:49" ]

[ null ]

[ "## Dimensions Math® 6–8 for Schools\n\nDimensions Math 6–8 brings the Singapore math approach into middle school. The program emphasizes problem solving and empowers students to think mathematically, both inside and outside the classroom. Pre-algebra, algebra, geometry, data analysis, probability, and some advanced math topics are included in this rigorous series. Dimensions Math 6–8 is a logical next step for students who completed Dimensions Math PK–5, or for students ready to gain a solid foundation for higher level math. Dimensions Math is designed to better serve U.S. teachers and students. The series follows the principles outlined in the Singapore mathematics framework, including the Concrete, Pictorial, Abstract (CPA) Approach, bar modeling, and more.\n\nTextbooks\n\nTextbooks provide a systematic, well-rounded approach to math that facilitates the internalization of concepts and instills curiosity. Lessons engage students with different levels of problem solving and real world application of math topics.\n\n1. Chapter Opener: Introduces a topic through a real world example and identifies learning objectives.\n\n2. Example: Helps students understand and master a concept through a worked example.\n\n3. Try It!: Gives students an opportunity to answer a similar question to check how well they have grasped the concept.\n\n4. Class Activity: Introduces new concepts through cooperative learning methods.\n\n5. Basic Practice: Provides simple questions that involve the direct application of concepts.\n\n6. Further Practice: Provides more challenging questions that involve the direct application of concepts.\n\n7. Math@Work: Provides questions that involve the application of integrated concepts to practical situations.\n\n8. Brainworks: Provides higher-order thinking questions that involve an open-ended approach to problem solving.\n\n9. In A Nutshell: Consolidates important rules and concepts for quick and easy review.\n\n10. Extend Your Learning Curve: Extends and applies concepts to problems that are investigative in nature and engages students in independent research.\n\nWorkbooks\n\nWorkbooks offer the necessary practice to hone concepts covered in the textbooks. Exercises help students polish their analytical skills and develop a stronger foundation. Workbooks A and B for each grade correspond to the two halves of the school year.\n\n1. Basic Practice: Simple questions that drill comprehension of concepts.\n\n2. Further Practice: More complex questions that involve direct application.\n\n3. Challenging Practice: Hard questions that require synthesis.\n\n4. Enrichment: Questions that demand higher order thinking, analysis, and reasoning.\n\nTEACHER’S GUIDES & TEACHING NOTES AND SOLUTIONS\n\nTeacher’s Guides (Grade 6) provide teaching suggestions and important information for educators to help students achieve math mastery.\n\nTeaching Notes and Solutions (Grades 7–8) contain detailed notes and fully worked solutions for all questions and problems in textbooks.\n\nWorkbook solutions\n\nWorkbook Solutions (Grades 6–8) contain fully worked solutions for problems in workbooks." ]

[ null ]

[ "# Rotate an object smoothly on the Y axis in Unity\n\nI am attempting a simple script to swing a door open in Unity. This requires a smooth rotation of 90 degrees around the Y axis. I have seen that one way to do this is using Unity's Quanternion object. I believed that this should work:\n\npublic class DoorOpenScript : MonoBehaviour\n{\n\npublic float smooth = 20;\n\n// Use this for initialization\nvoid Start ()\n{\nSwingOpen ();\n}\n\n// Update is called once per frame\nvoid Update ()\n{\n\n}\n\nvoid SwingOpen()\n{\nQuaternion newRotation = new Quaternion(transform.rotation.x,transform.rotation.y,transform.rotation.z,transform.rotation.w);;\nnewRotation *= Quaternion.Euler(0, 90, 0); // this add a 90 degrees Y rotation\ntransform.rotation= Quaternion.Slerp(transform.rotation, newRotation,20 * Time.deltaTime);\n\n}\n\n}\n\n\nHowever, this just opens the door completely. I have tried playing with the third parameter to Slerp but with no results. What am I doing incorrectly?\n\nThink about what you need to do, open the door over time. It's not going to happen all in one call in the Start function. You'll need to add a little more rotation each frame to rotate the object smoothly. Something like the following will rotate the object from 0 to 90 degrees over time:\n\nvoid Update () {\nSwingOpen();\n}\n\nvoid SwingOpen()\n{\nQuaternion newRotation = Quaternion.AngleAxis(90, Vector3.up);\ntransform.rotation= Quaternion.Slerp(transform.rotation, newRotation, .05f);\n}\n\n\nNotice it's using the Update() function instead of Start(). That's because we want to change it a little each frame. Using Slerp you'll notice that the object swings fast at first, then slower until finally reaching its rotation. The last parameter controls that rate of change, with 1 being instantly and 0 being never.\n\nPerhaps this is your intended behavior, if not you can also perform a constant rotation over time with something like the following:\n\npublic float rotationDegreesPerSecond = 45f;\npublic float rotationDegreesAmount = 90f;\nprivate float totalRotation = 0;\n// Use this for initialization\nvoid Start () {\n\n}\n\n// Update is called once per frame\nvoid Update () {\n//if we haven't reached the desired rotation, swing\n\nif(Mathf.Abs(totalRotation) < Mathf.Abs(rotationDegreesAmount))\nSwingOpen();\n}\n\nvoid SwingOpen()\n{\nfloat currentAngle = transform.rotation.eulerAngles.y;\ntransform.rotation =\nQuaternion.AngleAxis(currentAngle + (Time.deltaTime * degreesPerSecond), Vector3.up);\ntotalRotation += Time.deltaTime * degreesPerSecond;\n}\n\n\nIn this case, the rotation of the door will take 2 seconds to reach 90 degrees.\n\nAnd just a tip, setting the variables to public will allow you to edit them from the Unity editor. This means you can apply this same script to multiple objects, but change the values for each object without editing the script.\n\n• Sorry for my confusion, I understand the first part and it works as you describe. However, for the second method you illustrate, why does the line: if(transform.rotation.eulerAngles.y<rotationDegreesAmount) { SwingOpen(); } not prevent the object from rotating after the condition is met?(i.e. after the transform's rotation around the y axis reaches the specified rotation degrees amount)? Aug 28 '13 at 15:47\n• Well, that line is a bit sloppy. It does stop the object from rotating anymore if the rotation is positive. Really you should keep track of the total rotation so far. I'll update it.\n– House\nAug 28 '13 at 15:53\n• So that should rotate indefinitely? Aug 28 '13 at 16:02\n• I assumed you wanted it to stop after rotating a certain amount? The current code should rotate the door by 90 degrees and then stop. If you want to rotate it forever, you can remove the check.\n– House\nAug 28 '13 at 16:05\n• Yes, thank you that functions how you indicate. I had a typo I believe. Thank you for the informative response. Aug 28 '13 at 18:32" ]

[ null ]

[ "# Could the Hadamard gate have been constructed differently with similar characteristics?\n\nSay we had a Hadamard-like gate with the -1 in the first entry instead of the last. Let's call it $$H^1$$.\n\n$$H = \\begin{bmatrix}1&1\\\\1&-1\\end{bmatrix}$$\n\n$$H^1 = \\begin{bmatrix}-1&1\\\\1&1\\end{bmatrix}$$\n\nFrom my maths it's a unitary matrix, so it's a valid quantum gate that does the following:\n\n$$H^1|0\\rangle = \\left(\\frac{-|0\\rangle+|1\\rangle}{\\sqrt{2}}\\right)$$\n\n$$H^1|1\\rangle = \\left(\\frac{|0\\rangle+|1\\rangle}{\\sqrt{2}}\\right)$$\n\nThese are similar to the true Hadamard gate, but with the sign flipped on the $$|0\\rangle$$ instead of the $$|1\\rangle$$.\n\nWas the choice of the Hadamard as we know it an arbitrary decision like the right hand rule? Or is there a mathematical or historical reason for it?\n\nThe Hadamard gate has close ties to the discrete Fourier transform. Consider the DFT for an $$N$$-level system: $$\\vert j \\rangle = \\frac{1}{\\sqrt{N}} \\sum\\limits_{k=0}^{N-1} e^{\\frac{i2 \\pi j k}{N}} \\vert k \\rangle.$$ For $$N=2$$ this is simply $$\\vert j \\rangle = \\frac{1}{\\sqrt{2}}\\begin{bmatrix}1 & 1 \\\\ 1 & -1 \\end{bmatrix} \\, \\vert k \\rangle = H \\vert k \\rangle.$$ For $$H$$ applied to $$d$$ qubits in parallel, this generalizes naturally to a $$d$$-dimensional DFT, $$H^{\\otimes d}$$. In this sense, the sign convention of $$H$$ clearly aligns with its function as a unitary DFT matrix.\nThe choice of sign for $$H$$ also aligns, less directly, to the conventional $$X$$, $$Y$$, $$Z$$ basis of the Lie algebra $$\\mathfrak{su}_2$$. For example, $$H$$ plays a part in the spectral decomposition of $$X$$ as $$X = H Z H,$$ noting that $$H$$ is both unitary and Hermitian. That $$H$$ contains both the eigenvectors and dual-eigenvectors of $$X$$, with eigenvalues in $$Z$$ can be a useful property. $$H^1$$, as defined in the question, would swap the position of the eigenvalues.\nYou can easily check that $$H^1=XHX$$, which is another way to say that $$H^1$$ is the same as $$H$$ modulo swapping $$|0\\rangle$$ and $$|1\\rangle$$.\nOn the other hand, it is \"equivalent\" in the sense that, given an arbitrary circuit given as a sequence of gates $$\\prod_k U_k$$, if you swap all the $$|0\\rangle$$s and $$|1\\rangle$$s, all the $$H$$ gates will become $$H^1$$ gates (and vice versa)." ]

[ null ]

[ "Centre of Mass of a Solid of Revolution\n\nWhen a curve", null, "is rotated about the", null, "- axis, the centre of mass of the solid generated will line on the", null, "– axis because of the symmetry of the curve. The centre of mass will not lie on the", null, "– axis however.", null, "If the centre of gravity of a volume of revolution of mass", null, "is at", null, "then taking moments about the", null, "- axis for the section of solid of thickness", null, "of radius", null, "gives a mass for this section of", null, "so letting", null, "integrating and equating to the moment of the whole solid gives", null, "Similarly the centre of mass of the solid of revolution for a curve", null, "rotated about the", null, "- axis is", null, "where", null, "Example: Find the centre of gravity of the solid of revolution formed by", null, "between", null, "and", null, "", null, "", null, "", null, "", null, "", null, "", null, "", null, "", null, "", null, "", null, "", null, "", null, "", null, "", null, "" ]

[ null, "https://astarmathsandphysics.com/a-level-maths/M3/centre-of-mass-of-a-solid-of-revolution-html-m1208c819.gif", null, "https://astarmathsandphysics.com/a-level-maths/M3/centre-of-mass-of-a-solid-of-revolution-html-m36a6b165.gif", null, "https://astarmathsandphysics.com/a-level-maths/M3/centre-of-mass-of-a-solid-of-revolution-html-m36a6b165.gif", null, "https://astarmathsandphysics.com/a-level-maths/M3/centre-of-mass-of-a-solid-of-revolution-html-38088db4.gif", null, "https://astarmathsandphysics.com/a-level-maths/M3/centre-of-mass-of-a-solid-of-revolution-html-m3681e481.gif", null, "https://astarmathsandphysics.com/a-level-maths/M3/centre-of-mass-of-a-solid-of-revolution-html-m3bbc31df.gif", null, "https://astarmathsandphysics.com/a-level-maths/M3/centre-of-mass-of-a-solid-of-revolution-html-m63650dfd.gif", null, "https://astarmathsandphysics.com/a-level-maths/M3/centre-of-mass-of-a-solid-of-revolution-html-m36a6b165.gif", null, "https://astarmathsandphysics.com/a-level-maths/M3/centre-of-mass-of-a-solid-of-revolution-html-a52c33d.gif", null, "https://astarmathsandphysics.com/a-level-maths/M3/centre-of-mass-of-a-solid-of-revolution-html-38088db4.gif", null, "https://astarmathsandphysics.com/a-level-maths/M3/centre-of-mass-of-a-solid-of-revolution-html-m7f547b0e.gif", null, "https://astarmathsandphysics.com/a-level-maths/M3/centre-of-mass-of-a-solid-of-revolution-html-69b8db4d.gif", null, "https://astarmathsandphysics.com/a-level-maths/M3/centre-of-mass-of-a-solid-of-revolution-html-m6e6a0c52.gif", null, "https://astarmathsandphysics.com/a-level-maths/M3/centre-of-mass-of-a-solid-of-revolution-html-3e014069.gif", null, "https://astarmathsandphysics.com/a-level-maths/M3/centre-of-mass-of-a-solid-of-revolution-html-38088db4.gif", null, "https://astarmathsandphysics.com/a-level-maths/M3/centre-of-mass-of-a-solid-of-revolution-html-m10d2f6b0.gif", null, "https://astarmathsandphysics.com/a-level-maths/M3/centre-of-mass-of-a-solid-of-revolution-html-m134a8e20.gif", null, "https://astarmathsandphysics.com/a-level-maths/M3/centre-of-mass-of-a-solid-of-revolution-html-m6aff1bd0.gif", null, "https://astarmathsandphysics.com/a-level-maths/M3/centre-of-mass-of-a-solid-of-revolution-html-ma84c4d4.gif", null, "https://astarmathsandphysics.com/a-level-maths/M3/centre-of-mass-of-a-solid-of-revolution-html-5c651e11.gif", null, "https://astarmathsandphysics.com/a-level-maths/M3/centre-of-mass-of-a-solid-of-revolution-html-m697baccc.gif", null, "https://astarmathsandphysics.com/components/com_jcomments/images/smilies/redface.gif", null, "https://astarmathsandphysics.com/components/com_jcomments/images/smilies/redface.gif", null, "https://astarmathsandphysics.com/components/com_jcomments/images/smilies/sick.gif", null, "https://astarmathsandphysics.com/components/com_jcomments/images/smilies/normal.gif", null, "https://astarmathsandphysics.com/components/com_jcomments/images/smilies/normal.gif", null, "https://astarmathsandphysics.com/components/com_jcomments/images/smilies/cool.gif", null, "https://astarmathsandphysics.com/components/com_jcomments/images/smilies/whistling.gif", null, "https://astarmathsandphysics.com/components/com_jcomments/images/smilies/whistling.gif", null, "https://astarmathsandphysics.com/components/com_jcomments/images/smilies/whistling.gif", null, "https://astarmathsandphysics.com/components/com_jcomments/images/smilies/whistling.gif", null, "https://astarmathsandphysics.com/components/com_jcomments/images/smilies/rolleyes.gif", null, "https://astarmathsandphysics.com/components/com_jcomments/images/smilies/unsure.gif", null, "https://astarmathsandphysics.com/component/jcomments/captcha/78275.html", null ]

[ "Paul's Online Notes\nHome / Calculus II / Series & Sequences / Ratio Test\nShow Mobile Notice Show All Notes Hide All Notes\nMobile Notice\nYou appear to be on a device with a \"narrow\" screen width (i.e. you are probably on a mobile phone). Due to the nature of the mathematics on this site it is best views in landscape mode. If your device is not in landscape mode many of the equations will run off the side of your device (should be able to scroll to see them) and some of the menu items will be cut off due to the narrow screen width.\n\n### Section 4-10 : Ratio Test\n\nIn this section we are going to take a look at a test that we can use to see if a series is absolutely convergent or not. Recall that if a series is absolutely convergent then we will also know that it’s convergent and so we will often use it to simply determine the convergence of a series.\n\nBefore proceeding with the test let’s do a quick reminder of factorials. This test will be particularly useful for series that contain factorials (and we will see some in the applications) so let’s make sure we can deal with them before we run into them in an example.\n\nIf $$n$$ is an integer such that $$n \\ge 0$$ then $$n$$ factorial is defined as,\n\n\\begin{align*}n! & = n\\left( {n - 1} \\right)\\left( {n - 2} \\right) \\cdots \\left( 3 \\right)\\left( 2 \\right)\\left( 1 \\right) & \\hspace{0.15in} & {\\mbox{if }}n \\ge 1\\\\ 0! & = 1 & \\hspace{0.15in} & {\\mbox{by definition}}\\end{align*}\n\nLet’s compute a couple real quick.\n\n\\begin{align*}& 1! = 1\\\\ & 2! = 2\\left( 1 \\right) = 2\\\\ & 3! = 3\\left( 2 \\right)\\left( 1 \\right) = 6\\\\ & 4! = 4\\left( 3 \\right)\\left( 2 \\right)\\left( 1 \\right) = 24\\\\ & 5! = 5\\left( 4 \\right)\\left( 3 \\right)\\left( 2 \\right)\\left( 1 \\right) = 120\\end{align*}\n\nIn the last computation above, notice that we could rewrite the factorial in a couple of different ways. For instance,\n\n\\begin{align*}5! & = 5\\underbrace {\\left( 4 \\right)\\left( 3 \\right)\\left( 2 \\right)\\left( 1 \\right)}_{4!} = 5 \\cdot 4!\\\\ 5! & = 5\\left( 4 \\right)\\underbrace {\\left( 3 \\right)\\left( 2 \\right)\\left( 1 \\right)}_{3!} = 5\\left( 4 \\right) \\cdot 3!\\end{align*}\n\nIn general, we can always “strip out” terms from a factorial as follows.\n\n\\begin{align*}n! & = n\\left( {n - 1} \\right)\\left( {n - 2} \\right) \\cdots \\left( {n - k} \\right)\\left( {n - \\left( {k + 1} \\right)} \\right) \\cdots \\left( 3 \\right)\\left( 2 \\right)\\left( 1 \\right)\\\\ & = n\\left( {n - 1} \\right)\\left( {n - 2} \\right) \\cdots \\left( {n - k} \\right) \\cdot \\left( {n - \\left( {k + 1} \\right)} \\right)!\\\\ & = n\\left( {n - 1} \\right)\\left( {n - 2} \\right) \\cdots \\left( {n - k} \\right) \\cdot \\left( {n - k - 1} \\right)!\\end{align*}\n\nWe will need to do this on occasion so don’t forget about it.\n\nAlso, when dealing with factorials we need to be very careful with parenthesis. For instance, $$\\left( {2n} \\right)! \\ne 2\\,\\,n!$$ as we can see if we write each of the following factorials out.\n\n\\begin{align*}\\left( {2n} \\right)! & = \\left( {2n} \\right)\\left( {2n - 1} \\right)\\left( {2n - 2} \\right) \\cdots \\left( 3 \\right)\\left( 2 \\right)\\left( 1 \\right)\\\\ 2\\,\\,n! & = 2\\left[ {\\left( n \\right)\\left( {n - 1} \\right)\\left( {n - 2} \\right) \\cdots \\left( 3 \\right)\\left( 2 \\right)\\left( 1 \\right)} \\right]\\end{align*}\n\nAgain, we will run across factorials with parenthesis so don’t drop them. This is often one of the more common mistakes that students make when they first run across factorials.\n\nOkay, we are now ready for the test.\n\n#### Ratio Test\n\nSuppose we have the series $$\\displaystyle \\sum {{a_n}}$$. Define,\n\n$L = \\mathop {\\lim }\\limits_{n \\to \\infty } \\left| {\\frac{{{a_{n + 1}}}}{{{a_n}}}} \\right|$\n\nThen,\n\n1. if $$L < 1$$ the series is absolutely convergent (and hence convergent).\n\n2. if $$L > 1$$ the series is divergent.\n\n3. if $$L = 1$$ the series may be divergent, conditionally convergent, or absolutely convergent.\n\nA proof of this test is at the end of the section.\n\nNotice that in the case of $$L = 1$$ the ratio test is pretty much worthless and we would need to resort to a different test to determine the convergence of the series.\n\nAlso, the absolute value bars in the definition of $$L$$ are absolutely required. If they are not there it will be impossible for us to get the correct answer.\n\nLet’s take a look at some examples.\n\nExample 1 Determine if the following series is convergent or divergent. $\\sum\\limits_{n = 1}^\\infty {\\frac{{{{\\left( { - 10} \\right)}^n}}}{{{4^{2n + 1}}\\left( {n + 1} \\right)}}}$\nShow Solution\n\nWith this first example let’s be a little careful and make sure that we have everything down correctly. Here are the series terms $${a_n}$$.\n\n${a_n} = \\frac{{{{\\left( { - 10} \\right)}^n}}}{{{4^{2n + 1}}\\left( {n + 1} \\right)}}$\n\nRecall that to compute $${a_{n + 1}}$$ all that we need to do is substitute n+1 for all the $$n$$’s in $${a_n}$$.\n\n${a_{n + 1}} = \\frac{{{{\\left( { - 10} \\right)}^{n + 1}}}}{{{4^{2\\left( {n + 1} \\right) + 1}}\\left( {\\left( {n + 1} \\right) + 1} \\right)}} = \\frac{{{{\\left( { - 10} \\right)}^{n + 1}}}}{{{4^{2n + 3}}\\left( {n + 2} \\right)}}$\n\nNow, to define $$L$$ we will use,\n\n$L = \\mathop {\\lim }\\limits_{n \\to \\infty } \\left| {{a_{n + 1}} \\cdot \\frac{1}{{{a_n}}}} \\right|$\n\nsince this will be a little easier when dealing with fractions as we’ve got here. So,\n\n\\begin{align*}L & = \\mathop {\\lim }\\limits_{n \\to \\infty } \\left| {\\frac{{{{\\left( { - 10} \\right)}^{n + 1}}}}{{{4^{2n + 3}}\\left( {n + 2} \\right)}}\\,\\,\\frac{{{4^{2n + 1}}\\left( {n + 1} \\right)}}{{{{\\left( { - 10} \\right)}^n}}}} \\right|\\\\ & = \\mathop {\\lim }\\limits_{n \\to \\infty } \\left| {\\frac{{ - 10\\left( {n + 1} \\right)}}{{{4^2}\\left( {n + 2} \\right)}}} \\right|\\\\ & = \\frac{{10}}{{16}}\\mathop {\\lim }\\limits_{n \\to \\infty } \\frac{{n + 1}}{{n + 2}}\\\\ & = \\frac{{10}}{{16}} < 1\\end{align*}\n\nSo, $$L < 1$$ and so by the Ratio Test the series converges absolutely and hence will converge.\n\nAs seen in the previous example there is usually a lot of canceling that will happen in these. Make sure that you do this canceling. If you don’t do this kind of canceling it can make the limit fairly difficult.\n\nExample 2 Determine if the following series is convergent or divergent. $\\sum\\limits_{n = 0}^\\infty {\\frac{{n!}}{{{5^n}}}}$\nShow Solution\n\nNow that we’ve worked one in detail we won’t go into quite the detail with the rest of these. Here is the limit.\n\n$L = \\mathop {\\lim }\\limits_{n \\to \\infty } \\left| {\\frac{{\\left( {n + 1} \\right)!}}{{{5^{n + 1}}}}\\,\\frac{{{5^n}}}{{n!}}} \\right| = \\mathop {\\lim }\\limits_{n \\to \\infty } \\frac{{\\left( {n + 1} \\right)!}}{{5\\,\\,n!}}$\n\nIn order to do this limit we will need to eliminate the factorials. We simply can’t do the limit with the factorials in it. To eliminate the factorials we will recall from our discussion on factorials above that we can always “strip out” terms from a factorial. If we do that with the numerator (in this case because it’s the larger of the two) we get,\n\n$L = \\mathop {\\lim }\\limits_{n \\to \\infty } \\frac{{\\left( {n + 1} \\right)\\,\\,n!}}{{5\\,\\,n!}}$\n\nat which point we can cancel the $$n$$! for the numerator an denominator to get,\n\n$L = \\mathop {\\lim }\\limits_{n \\to \\infty } \\frac{{\\left( {n + 1} \\right)}}{5} = \\infty > 1$\n\nSo, by the Ratio Test this series diverges.\n\nExample 3 Determine if the following series is convergent or divergent. $\\sum\\limits_{n = 2}^\\infty {\\frac{{{n^2}}}{{\\left( {2n - 1} \\right)!}}}$\nShow Solution\n\nIn this case be careful in dealing with the factorials.\n\n\\begin{align*}L & = \\mathop {\\lim }\\limits_{n \\to \\infty } \\left| {\\frac{{{{\\left( {n + 1} \\right)}^2}}}{{\\left( {2\\left( {n + 1} \\right) - 1} \\right)!}}\\,\\frac{{\\left( {2n - 1} \\right)!}}{{{n^2}}}} \\right|\\\\ & = \\mathop {\\lim }\\limits_{n \\to \\infty } \\left| {\\frac{{{{\\left( {n + 1} \\right)}^2}}}{{\\left( {2n + 1} \\right)!}}\\,\\frac{{\\left( {2n - 1} \\right)!}}{{{n^2}}}} \\right|\\\\ & = \\mathop {\\lim }\\limits_{n \\to \\infty } \\frac{{{{\\left( {n + 1} \\right)}^2}}}{{\\left( {2n + 1} \\right)\\left( {2n} \\right)\\left( {2n - 1} \\right)!}}\\,\\frac{{\\left( {2n - 1} \\right)!}}{{{n^2}}}\\\\ & = \\mathop {\\lim }\\limits_{n \\to \\infty } \\frac{{{{\\left( {n + 1} \\right)}^2}}}{{\\left( {2n + 1} \\right)\\left( {2n} \\right)\\left( {{n^2}} \\right)}}\\\\ & = 0 < 1\\end{align*}\n\nSo, by the Ratio Test this series converges absolutely and so converges.\n\nExample 4 Determine if the following series is convergent or divergent. $\\sum\\limits_{n = 1}^\\infty {\\frac{{{9^n}}}{{{{\\left( { - 2} \\right)}^{n + 1}}\\,n}}}$\nShow Solution\n\nDo not mistake this for a geometric series. The $$n$$ in the denominator means that this isn’t a geometric series. So, let’s compute the limit.\n\n\\begin{align*}L & = \\mathop {\\lim }\\limits_{n \\to \\infty } \\left| {\\frac{{{9^{n + 1}}}}{{{{\\left( { - 2} \\right)}^{n + 2}}\\,\\left( {n + 1} \\right)}}\\,\\,\\frac{{{{\\left( { - 2} \\right)}^{n + 1}}\\,\\,n}}{{{9^n}}}} \\right|\\\\ & = \\mathop {\\lim }\\limits_{n \\to \\infty } \\left| {\\frac{{9\\,n}}{{\\left( { - 2} \\right)\\,\\left( {n + 1} \\right)}}} \\right|\\\\ & = \\frac{9}{2}\\mathop {\\lim }\\limits_{n \\to \\infty } \\frac{n}{{n + 1}}\\\\ & = \\frac{9}{2} > 1\\end{align*}\n\nTherefore, by the Ratio Test this series is divergent.\n\nIn the previous example the absolute value bars were required to get the correct answer. If we hadn’t used them we would have gotten $$L = - \\frac{9}{2} < 1$$ which would have implied a convergent series!\n\nNow, let’s take a look at a couple of examples to see what happens when we get$$L = 1$$. Recall that the ratio test will not tell us anything about the convergence of these series. In both of these examples we will first verify that we get $$L = 1$$ and then use other tests to determine the convergence.\n\nExample 5 Determine if the following series is convergent or divergent. $\\sum\\limits_{n = 0}^\\infty {\\frac{{{{\\left( { - 1} \\right)}^n}}}{{{n^2} + 1}}}$\nShow Solution\n\nLet’s first get $$L$$.\n\n$L = \\mathop {\\lim }\\limits_{n \\to \\infty } \\left| {\\frac{{{{\\left( { - 1} \\right)}^{n + 1}}}}{{{{\\left( {n + 1} \\right)}^2} + 1}}\\,\\,\\frac{{{n^2} + 1}}{{{{\\left( { - 1} \\right)}^n}}}} \\right| = \\mathop {\\lim }\\limits_{n \\to \\infty } \\frac{{{n^2} + 1}}{{{{\\left( {n + 1} \\right)}^2} + 1}} = 1$\n\nSo, as implied earlier we get $$L = 1$$ which means the ratio test is no good for determining the convergence of this series. We will need to resort to another test for this series. This series is an alternating series and so let’s check the two conditions from that test.\n\n$\\mathop {\\lim }\\limits_{n \\to \\infty } {b_n} = \\mathop {\\lim }\\limits_{n \\to \\infty } \\frac{1}{{{n^2} + 1}} = 0$ ${b_n} = \\frac{1}{{{n^2} + 1}} > \\frac{1}{{{{\\left( {n + 1} \\right)}^2} + 1}} = {b_{n + 1}}$\n\nThe two conditions are met and so by the Alternating Series Test this series is convergent. We’ll leave it to you to verify this series is also absolutely convergent.\n\nExample 6 Determine if the following series is convergent or divergent. $\\sum\\limits_{n = 0}^\\infty {\\frac{{n + 2}}{{2n + 7}}}$\nShow Solution\n\nHere’s the limit.\n\n$L = \\mathop {\\lim }\\limits_{n \\to \\infty } \\left| {\\frac{{n + 3}}{{2\\left( {n + 1} \\right) + 7}}\\,\\,\\frac{{2n + 7}}{{n + 2}}} \\right| = \\mathop {\\lim }\\limits_{n \\to \\infty } \\frac{{\\left( {n + 3} \\right)\\left( {2n + 7} \\right)}}{{\\left( {2n + 9} \\right)\\left( {n + 2} \\right)}} = 1$\n\nAgain, the ratio test tells us nothing here. We can however, quickly use the divergence test on this. In fact that probably should have been our first choice on this one anyway.\n\n$\\mathop {\\lim }\\limits_{n \\to \\infty } \\frac{{n + 2}}{{2n + 7}} = \\frac{1}{2} \\ne 0$\n\nBy the Divergence Test this series is divergent.\n\nSo, as we saw in the previous two examples if we get $$L = 1$$ from the ratio test the series can be either convergent or divergent.\n\nThere is one more thing that we should note about the ratio test before we move onto the next section. The last series was a polynomial divided by a polynomial and we saw that we got $$L = 1$$ from the ratio test. This will always happen with rational expression involving only polynomials or polynomials under radicals. So, in the future it isn’t even worth it to try the ratio test on these kinds of problems since we now know that we will get $$L = 1$$.\n\nAlso, in the second to last example we saw an example of an alternating series in which the positive term was a rational expression involving polynomials and again we will always get $$L = 1$$ in these cases.\n\nLet’s close the section out with a proof of the Ratio Test.\n\n#### Proof of Ratio Test\n\nFirst note that we can assume without loss of generality that the series will start at $$n = 1$$ as we’ve done for all our series test proofs.\n\nLet’s start off the proof here by assuming that $$L < 1$$ and we’ll need to show that $$\\sum {{a_n}}$$ is absolutely convergent. To do this let’s first note that because $$L < 1$$ there is some number $$r$$ such that $$L < r < 1$$.\n\nNow, recall that,\n\n$L = \\mathop {\\lim }\\limits_{n \\to \\infty } \\left| {\\frac{{{a_{n + 1}}}}{{{a_n}}}} \\right|$\n\nand because we also have chosen $$r$$ such that $$L < r$$ there is some $$N$$ such that if $$n \\ge N$$ we will have,\n\n$\\left| {\\frac{{{a_{n + 1}}}}{{{a_n}}}} \\right| < r\\hspace{0.5in} \\Rightarrow \\hspace{0.5in}\\left| {{a_{n + 1}}} \\right| < r\\left| {{a_n}} \\right|$\n\nNext, consider the following,\n\n\\begin{align*}\\left| {{a_{N + 1}}} \\right| & < r\\left| {{a_N}} \\right|\\\\ \\left| {{a_{N + 2}}} \\right| & < r\\left| {{a_{N + 1}}} \\right| < {r^2}\\left| {{a_N}} \\right|\\\\ \\left| {{a_{N + 3}}} \\right| & < r\\left| {{a_{N + 2}}} \\right| < {r^3}\\left| {{a_N}} \\right|\\\\ & \\hspace{0.5in} \\vdots \\\\ \\left| {{a_{N + k}}} \\right| & < r\\left| {{a_{N + k - 1}}} \\right| < {r^k}\\left| {{a_N}} \\right|\\end{align*}\n\nSo, for $$k = 1,2,3, \\ldots$$ we have $$\\left| {{a_{N + k}}} \\right| < {r^k}\\left| {{a_N}} \\right|$$. Just why is this important? Well we can now look at the following series.\n\n$\\sum\\limits_{k = 0}^\\infty {\\left| {{a_N}} \\right|{r^k}}$\n\nThis is a geometric series and because $$0 < r < 1$$ we in fact know that it is a convergent series. Also because $$\\left| {{a_{N + k}}} \\right| < {r^k}\\left| {{a_N}} \\right|$$ by the Comparison test the series\n\n$\\sum\\limits_{n = N + 1}^\\infty {\\left| {{a_n}} \\right|} = \\sum\\limits_{k = 1}^\\infty {\\left| {{a_{N + k}}} \\right|}$\n\nis convergent. However since,\n\n$\\sum\\limits_{n = 1}^\\infty {\\left| {{a_n}} \\right|} = \\sum\\limits_{n = 1}^N {\\left| {{a_n}} \\right|} + \\sum\\limits_{n = N + 1}^\\infty {\\left| {{a_n}} \\right|}$\n\nwe know that $$\\sum\\limits_{n = 1}^\\infty {\\left| {{a_n}} \\right|}$$ is also convergent since the first term on the right is a finite sum of finite terms and hence finite. Therefore $$\\sum\\limits_{n = 1}^\\infty {{a_n}}$$ is absolutely convergent.\n\nNext, we need to assume that $$L > 1$$ and we’ll need to show that $$\\sum {{a_n}}$$ is divergent. Recalling that,\n\n$L = \\mathop {\\lim }\\limits_{n \\to \\infty } \\left| {\\frac{{{a_{n + 1}}}}{{{a_n}}}} \\right|$\n\nand because $$L > 1$$ we know that there must be some $$N$$ such that if $$n \\ge N$$ we will have,\n\n$\\left| {\\frac{{{a_{n + 1}}}}{{{a_n}}}} \\right| > 1\\hspace{0.5in} \\Rightarrow \\hspace{0.5in}\\left| {{a_{n + 1}}} \\right| > \\left| {{a_n}} \\right|$\n\nHowever, if $$\\left| {{a_{n + 1}}} \\right| > \\left| {{a_n}} \\right|$$ for all $$n \\ge N$$ then we know that,\n\n$\\mathop {\\lim }\\limits_{n \\to \\infty } \\left| {{a_n}} \\right| \\ne 0$\n\nbecause the terms are getting larger and guaranteed to not be negative. This in turn means that,\n\n$\\mathop {\\lim }\\limits_{n \\to \\infty } {a_n} \\ne 0$\n\nTherefore, by the Divergence Test $$\\sum {{a_n}}$$ is divergent.\n\nFinally, we need to assume that $$L = 1$$ and show that we could get a series that has any of the three possibilities. To do this we just need a series for each case. We’ll leave the details of checking to you but all three of the following series have $$L = 1$$ and each one exhibits one of the possibilities.\n\n\\begin{align*}& \\sum\\limits_{n = 1}^\\infty {\\frac{1}{{{n^2}}}} & \\hspace{0.5in}&{\\mbox{absolutely convergent}}\\\\ & \\sum\\limits_{n = 1}^\\infty {\\frac{{{{\\left( { - 1} \\right)}^n}}}{n}} & \\hspace{0.5in}&{\\mbox{conditionally convergent}}\\\\ & \\sum\\limits_{n = 1}^\\infty {\\frac{1}{n}} & \\hspace{0.5in}&{\\mbox{divergent}}\\end{align*}\njizzjizzjizz日本老师免费人成网站线观看含羞成年片黄网站色大全免费观看婷婷网色偷偷亚洲男人的天堂" ]

[ null ]

[ "# DC FUNDAMENTAL TRAINER", null, "### Objectives\n\nThe DC Fundamental Trainer provides comprehensive, hands-on instruction in the terminology, principles and applications of DC circuits following a carefully designed Instructional manual.\n\n### Topic Covers:\n\n• Instrument familiarization\n• Symbols and schematics\n• Circuit Voltage\n• Circuit Current\n• Circuit Resistance\n• DC Power Sources in Series and in Parallel Series\n• Opposing DC Sources\n• Identify Types of Switches\n• Switching Concepts\n• Ohm's Law: Circuit Resistance\n• Circuit Resistance\n• Ohm's Law: Circuit Current\n• Ohm's Law: Circuit Voltage\n• Resistance in a Series Resistive Circuit\n• Current in a Series Resistive Circuit\n• Voltage in a Series Resistive Circuit\n• Resistance in a Parallel Resistive Circuit\n• Voltage and Current in a Parallel Resistive Circuit\n• Resistance in a Series - Parallel Resistive Circuit\n• Voltage in a Series - Parallel Resistive Circuit\n• Current in a Series - Parallel Resistive CircuitPower in a Series Resistive Circuit\n• Power in a Parallel Resistive Circuit\n• Power in a Series - Parallel Resistive Circuit\n• The Rheostat\n• The Potentiometer\n• Voltage Dividers\n• The DC Ammeter\n• The DC Ohmmeter\n• The DC Voltmeter\n• Troubleshooting DC Circuits\n• Voltage Divider\n• Voltmeter/Ammeter/Ohmmeter\n\n### Circuit Blocks:\n\n• LDR characteristics\n• Ohm's Law\n• Series Circuit\n• Parallel Circuit\n• Series/Parallel Circuit\n• Measurement of Power\n• Maximum Power transfer theorem\n• Magnetism and electromagnetism\n• Network theorem\n• Linear/Non-Linear Variable Resistor Voltage Divider Voltmeter/Ammeter/Ohmmeter\n\n### Features of the Trainer:\n\nBuilt in Regulated Power Supply DC (+1.2V to +15V)/500mA,(-1.2v to -15v)/500mA Voltage range : AC 100V - 230 V Frequency range : 50 - 60Hz It is housed in an elegant metal cabinet(CNC Machine finish) 45cm x 45cm x 18cm 6 Kg (approx).\n\nThis trainer is a glass-epoxy printed circuit board and all the symbols screen-printed on the front panel so that it enables the student to conduct the experiments easily\n\n### Accessories:\n\n• 2mm multi coloured moulded patch cords with daisying facility.\n• Computer simulated outputs and Step-By-Step detailed instructions are provided with the instruction manual.\n• Single strand wires.\n• Aligner.\nN2\nModel: N2 VERIFICATION OF BOOLEAN EXPRESSIONS Objective To...\nN3\nModel: N3 ADDER/SUBTRACTOR USING EX-OR GATES Objective To...\nN4\nModel: N4 R-S/D/T FLIP-FLOPS CHARACTERISTICS &...\nN5\nModel: N5 J-K FLIP FLOPS Objective To study...\nN6\nModel: N6 MASTER SLAVE J-K FLIP-FLOP...\nN7\nModel: N7 DIODE MATRIX ENCODER Objective To convert...\nP1\nModel:P1 OPERATIONAL AMPLIFIER CHARACTERISTICS   Objectives To study the...\nP2\nModel:P2 VOLTAGE FOLLOWER   Objectives To verify that the...\nP3\nModel:P3 SUMMER /SUBTRACTOR /DIFFERENTIATOR AND INTEGRATOR...\nP4\nModel:P4 VOLTAGE TO FREQUENCY CONVERTER   Objectives To construct...\nP5\nModel:P5 FREQUENCY- TO-VOLTAGE CONVERTER   Objectives To verify that...\nP6\nModel:P6 VOLTAGE TO CURRENT & CURRENT...\nP7\nModel:P7 PRECISION HALF WAVE & FULL...\nANTENNA SYSTEM TRAINER - AST\nModel: AST ANTENNA SYSTEM TRAINER 700MHZ...\nBLUETOOTH TRAINER - BTT\nModel: BTT BLUETOOTH TRAINER Objectives Study of Bluetooth...\nDOPPLER RADAR TRAINING SYSTEM - DRTS\nModel:DRTS DOPPLER RADAR TRAINING SYSTEM Objectives Study of...\nISDN TRAINER - ISDN\nModel:ISDN ISDN TRAINER INTRODUCTION LAB ELECTRONICS ISDN TRAINER...", null, "" ]

[ null, "https://www.labelectronics.com/images/X33.jpg", null, "https://www.labelectronics.com/images/logo_footer.png", null ]

[ "Lemma 103.3.3. Let $\\mathcal{X}$ be an algebraic stack. Notation as in Cohomology of Stacks, Lemma 102.14.2.\n\n1. Let $\\mathcal{H}$ be a quasi-coherent $\\mathcal{O}_{\\mathcal{X}_{lisse,{\\acute{e}tale}}}$-module on the lisse-étale site of $\\mathcal{X}$. For all $p \\in \\mathbf{Z}$ the sheaf $H^ p(Lg_!\\mathcal{H})$ is a locally quasi-coherent module with the flat base change property on $\\mathcal{X}$.\n\n2. Let $\\mathcal{H}$ be a quasi-coherent $\\mathcal{O}_{\\mathcal{X}_{flat,fppf}}$-module on the flat-fppf site of $\\mathcal{X}$. For all $p \\in \\mathbf{Z}$ the sheaf $H^ p(Lg_!\\mathcal{H})$ is a locally quasi-coherent module with the flat base change property on $\\mathcal{X}$.\n\nProof. Pick a scheme $U$ and a surjective smooth morphism $x : U \\to \\mathcal{X}$. By Modules on Sites, Definition 18.23.1 there exists an étale (resp. fppf) covering $\\{ U_ i \\to U\\} _{i \\in I}$ such that each pullback $f_ i^{-1}\\mathcal{H}$ has a global presentation (see Modules on Sites, Definition 18.17.1). Here $f_ i : U_ i \\to \\mathcal{X}$ is the composition $U_ i \\to U \\to \\mathcal{X}$ which is a morphism of algebraic stacks. (Recall that the pullback “is” the restriction to $\\mathcal{X}/f_ i$, see Sheaves on Stacks, Definition 95.9.2 and the discussion following.) After refining the covering we may assume each $U_ i$ is an affine scheme. Since each $f_ i$ is smooth (resp. flat) by Lemma 103.3.2 we see that $f_ i^{-1}Lg_!\\mathcal{H} = Lg_{i, !}(f'_ i)^{-1}\\mathcal{H}$. Using Cohomology of Stacks, Lemma 102.8.2 we reduce the statement of the lemma to the case where $\\mathcal{H}$ has a global presentation and where $\\mathcal{X} = (\\mathit{Sch}/X)_{fppf}$ for some affine scheme $X = \\mathop{\\mathrm{Spec}}(A)$.\n\nSay our presentation looks like\n\n$\\bigoplus \\nolimits _{j \\in J} \\mathcal{O} \\longrightarrow \\bigoplus \\nolimits _{i \\in I} \\mathcal{O} \\longrightarrow \\mathcal{H} \\longrightarrow 0$\n\nwhere $\\mathcal{O} = \\mathcal{O}_{\\mathcal{X}_{lisse,{\\acute{e}tale}}}$ (resp. $\\mathcal{O} = \\mathcal{O}_{\\mathcal{X}_{flat,fppf}}$). Note that the site $\\mathcal{X}_{lisse,{\\acute{e}tale}}$ (resp. $\\mathcal{X}_{flat,fppf}$) has a final object, namely $X/X$ which is quasi-compact (see Cohomology on Sites, Section 21.16). Hence we have\n\n$\\Gamma (\\bigoplus \\nolimits _{i \\in I} \\mathcal{O}) = \\bigoplus \\nolimits _{i \\in I} A$\n\nby Sites, Lemma 7.17.7. Hence the map in the presentation corresponds to a similar presentation\n\n$\\bigoplus \\nolimits _{j \\in J} A \\longrightarrow \\bigoplus \\nolimits _{i \\in I} A \\longrightarrow M \\longrightarrow 0$\n\nof an $A$-module $M$. Moreover, $\\mathcal{H}$ is equal to the restriction to the lisse-étale (resp. flat-fppf) site of the quasi-coherent sheaf $M^ a$ associated to $M$. Choose a resolution\n\n$\\ldots \\to F_2 \\to F_1 \\to F_0 \\to M \\to 0$\n\nby free $A$-modules. The complex\n\n$\\ldots \\mathcal{O} \\otimes _ A F_2 \\to \\mathcal{O} \\otimes _ A F_1 \\to \\mathcal{O} \\otimes _ A F_0 \\to \\mathcal{H} \\to 0$\n\nis a resolution of $\\mathcal{H}$ by free $\\mathcal{O}$-modules because for each object $U/X$ of $\\mathcal{X}_{lisse,{\\acute{e}tale}}$ (resp. $\\mathcal{X}_{flat,fppf}$) the structure morphism $U \\to X$ is flat. Hence by construction the value of $Lg_!\\mathcal{H}$ is\n\n$\\ldots \\to \\mathcal{O}_\\mathcal {X} \\otimes _ A F_2 \\to \\mathcal{O}_\\mathcal {X} \\otimes _ A F_1 \\to \\mathcal{O}_\\mathcal {X} \\otimes _ A F_0 \\to 0 \\to \\ldots$\n\nSince this is a complex of quasi-coherent modules on $\\mathcal{X}_{\\acute{e}tale}$ (resp. $\\mathcal{X}_{fppf}$) it follows from Cohomology of Stacks, Proposition 102.8.1 that $H^ p(Lg_!\\mathcal{H})$ is quasi-coherent. $\\square$\n\nIn your comment you can use Markdown and LaTeX style mathematics (enclose it like $\\pi$). A preview option is available if you wish to see how it works out (just click on the eye in the toolbar)." ]

[ null ]

[ "# dummy coding in sparklyr?\n\nDear list,\n\nI am trying to dummy code a factor and do a simple regression model. I used ft_one_hot_encoder to do it, but the results are different with those from lm() in R base. Could you help me understand this please?\n\nAlso, could ml_* machine learning functions provide standard error, especially for the regression models? I need info for significance test.\n\nI heard that it might also possible to do the dummy coding using mutate function, it looks like that mutate is quite flexible in creating new columns, could any one give me some hint how to create dummy coding with mutate function? Thank you very much.\n\nPlease find the codes and results below:\n\n``````sc_mtcars%>%ft_one_hot_encoder(\"gear\",\"gear1\")%>%ml_linear_regression(hp~gear1+wt)\nFormula: hp ~ gear1 + wt\n\nCoefficients:\n(Intercept) gear1_0 gear1_1 gear1_2 gear1_3 gear1_4 wt\n69.84297 0.00000 0.00000 0.00000 -79.65578 -105.33888 47.76914\n> summary(lm(hp~as.factor(gear)+wt,data=mtcars))\n\nCall:\nlm(formula = hp ~ as.factor(gear) + wt, data = mtcars)\n\nResiduals:\nMin 1Q Median 3Q Max\n-81.069 -21.774 -3.935 11.983 94.621\n\nCoefficients:\nEstimate Std. Error t value Pr(>|t|)\n(Intercept) -9.813 38.648 -0.254 0.80143\nas.factor(gear)4 -25.683 19.513 -1.316 0.19878\nas.factor(gear)5 79.656 23.600 3.375 0.00218 **\nwt 47.769 9.581 4.986 2.88e-05 ***\n---\nSignif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1\n\nResidual standard error: 39.27 on 28 degrees of freedom\nMultiple R-squared: 0.7037,\tAdjusted R-squared: 0.672\nF-statistic: 22.17 on 3 and 28 DF, p-value: 1.482e-07\n``````\n``````library(tidyverse)\nmtcars %>% as_tibble() %>%\nmutate(gear3=(case_when(gear %in% 3 ~ 1, TRUE ~ 0)),\ngear4=(case_when(gear %in% 4 ~ 1, TRUE ~ 0)),\ngear5=(case_when(gear %in% 5 ~ 1, TRUE ~ 0))) -> mtcars\n``````\n1 Like\n\nThank you very much, Chuck:)\n\n1 Like\n\nIf your question's been answered (even by you!), would you mind choosing a solution? It helps other people see which questions still need help, or find solutions if they have similar problems. Here’s how to do it:\n\nThanks @cderv\n\nMy question on dummy coding has been answered.\n\nIm still waiting to see if someone knows the possibility to get the standard error of the model estimates from ml_linear_regression(), ml_logistic_regression(), and so on. Hopefully someone knows something about it:)\n\n1 Like\n\nyou might want to open another question with a title that makes it clear what you are asking.\n\n1 Like\n\nThis topic was automatically closed 7 days after the last reply. New replies are no longer allowed.\n\nIf you have a query related to it or one of the replies, start a new topic and refer back with a link." ]

[ null ]

[ "2x + y = -2 x + y = 5 The x-coordinate of the solution to the system shown is _____.\nQuestion\nUpdated 4/9/2014 10:49:37 AM\nThis conversation has been flagged as incorrect.\nFlagged by yeswey [4/9/2014 10:36:27 AM]\ns\nOriginal conversation\nUser: 2x + y = -2 x + y = 5 The x-coordinate of the solution to the system shown is _____.\n\nWeegy: 2x + y = -2 x + y = 5 The x-coordinate of the solution to the system shown is -7\naisonyu|Points 270|\n\nUser: 3x + 5y = 78 2x - y = 0 The point of intersection of the lines has an x-coordinate of _____.\n\nWeegy: 6 is correct\nshifa saleheen|Points 9966|\n\nUser: 3x - 4y = 6 6x - 8y = 10 The system shown has _____ solution(s).\n\nWeegy: The system shown has no solution(s).\nstickman|Points 6262|\n\nUser: x - y = 4 x + y = 8 The x-coordinate of the solution to the system shown is _____.\n\njaps2310qa|Points 1979|\n\nUser: 3x - 4y = 7 3x + 2y = -5 When the second equation is subtracted from the first, the resulting equation is _____.\n\nWeegy: -6y = 12\nyestfl|Points 1444|\n\nUser: 7x - 3y = 4 2x - 4y = 1 Which of the following systems is not the same as solving the system shown? 28x - 12y = 16 and -6x + 12y = -3 14x - 6y = 4 and -14x + 28y = 1 -28x + 12y = -16 and 28x - 56y = 14\n\nWeegy: (28x - 12y = 16 and -6x 12y = -3) is not the same as solving the system.\nFrankie17851|Points 3200|\n\nUser: x + 5y = -2 2x + y = 5 The point of intersection of the lines has a y-coordinate of _____.\n\nWeegy: y-coordinate of -1\nyestfl|Points 1444|\n\nUser: 2x + 3y = 6 5x + 2y = 4 Which of the following equations could be the result of multiplication and addition to eliminate a variable in the system of equations?\n\nWeegy: c. 11y = 22\nshifa saleheen|Points 9966|\n\nUser: 5x + y = 6 5x + 3y = -4 The y-coordinate of the solution to the system shown is _____.\n\nWeegy: that would be -5\nyestfl|Points 1444|\n\nUser: x + y = k x - y = k The solution to the system shown is _____.\n\nWeegy: Let's use the reduction method by adding them up, you'll cancel out the y's, leaving you with x=k Now if x=k, let's replace k by x x-y=k x-y=x x-x=y 0=y Since x = k and 0 = y, [ we'll say that the solution to this system is (K,0) ]\napz13apz|Points 291|\n\nUser: 7x - 3y = 4 2x - 4y = 1 The solution to the system of equations is _____.\n\nWeegy: A.True\nrhyann24|Points 2455|\n\nQuestion\nUpdated 4/9/2014 10:49:37 AM\nThis conversation has been flagged as incorrect.\nFlagged by yeswey [4/9/2014 10:36:27 AM]\nRating\n3\nx - y = 4, x + y = 8 The x-coordinate of the solution to the system shown is 6.\nConfirmed by andrewpallarca [4/9/2014 10:53:11 AM]\n3\n7x - 3y = 4 multiple 4 on both sides 28x - 12y = 16\n2x - 4y = 1 multiple 3 on both sides 6x - 12y = 3\nSubtract the new equations 22x = 13, so x = 13/22\n7(13/22) - 3y = 4\n91/22 - 4 = 3y\n3y = 3/22\ny = 1/22\n7x - 3y = 4 2x - 4y = 1 The solution to the system of equations is (13/22, 1/22)\nConfirmed by andrewpallarca [4/9/2014 10:53:12 AM]\n\nQuestions asked by the same visitor\nWho proposed the formation of the League of Nations.\nWeegy: President Woodrow Wilson proposed the formation of the League of Nations. (More)\nQuestion\nUpdated 4/8/2014 1:44:44 PM\n32,216,269\nGET\nGET THE APP.\nweegy*", null, "*\nGet answers from Weegy and a team of really smart live experts.\nPopular Conversations\nReforestation always occurs as a result of human intervention. ...\nWeegy: Reforestation always occurs as a result of human intervention.- is TRUE. User: The principal characteristic ...\nLuteinzing hormones stimulate\nYou should replace your __________ every 15,000 miles.\nWeegy: You should replace your Fuel filter every 15,000 miles. User: Leaking purple fluid indicates that you should ...\nNation was knocked out of World War II first\nWhich of the following human relations skills is most clearly related ...\nWeegy: Which of the following human relations skills is most clearly related to [ communication - ] User: ...\nS\nL\nP\nR\nP\nR\nL\nP\nP\nC\nR\nP\nR\nL\nP\nR\nP\nR\nPoints 1320 [Total 15075] Ratings 5 Comments 1250 Invitations 2 Online\nS\nL\nP\nL\nP\nP\nPoints 1301 [Total 9401] Ratings 0 Comments 1301 Invitations 0 Offline\nS\nL\nPoints 814 [Total 1185] Ratings 0 Comments 814 Invitations 0 Offline\nS\nL\nP\n1\nL\nPoints 767 [Total 5050] Ratings 8 Comments 687 Invitations 0 Offline\nS\nL\nP\nP\nP\n1\nP\nL\nPoints 495 [Total 7946] Ratings 11 Comments 385 Invitations 0 Offline\nS\nL\nL\n1\nPoints 456 [Total 6372] Ratings 6 Comments 396 Invitations 0 Offline\nS\nL\nPoints 441 [Total 472] Ratings 0 Comments 1 Invitations 44 Offline\nS\nL\nPoints 229 [Total 314] Ratings 1 Comments 219 Invitations 0 Offline\nS\nL\nPoints 225 [Total 2759] Ratings 3 Comments 195 Invitations 0 Offline\nS\nL\n1\nPoints 224 [Total 4228] Ratings 8 Comments 144 Invitations 0 Offline\n* Excludes moderators and previous\nwinners (Include)\nHome | Contact | Blog | About | Terms | Privacy | © Purple Inc." ]

[ null, "https://www.weegy.com/img/ad-appstore-4.png", null ]

[ "# 基本循环语句的使用，兔子繁衍问题\n\n``````#include <stdio.h>\nint main()\n{\nint num,sum=0;\nscanf(\"%d\",&num);\nwhile(num>0){\nif(num%2==1){\nsum+=num;\n}\nscanf(\"%d\",&num);\n}\nprintf(\"%d\",sum);\nreturn 0;\n}\n``````\n\n### 输入格式:\n\n``````#include <stdio.h>\n#include <stdlib.h>\n\nint main(void) {\nint n,num,min;\nscanf(\"%d\",&n);\nfor(int i=1;i<=n;i++){\nscanf(\"%d\",&num);\nif(i==1){\nmin=num;\n}\nif(min>num){\nmin=num;\n}\n}\nprintf(\"min = %d\",min);\nreturn EXIT_SUCCESS;\n}\n``````\n\n### 输入样例:\n\n``````30\n``````\n``````#include <stdio.h>\n#include <math.h>\nint main(){\nint a,n,sum=0,count;\nscanf(\"%d %d\",&a,&n);\ncount=a;\nfor(int i=1;i<=n;i++){\nsum+=a;\na=a*10+count;\n}\nprintf(\"s = %d\",sum);\nreturn 0;\n}\n``````\n\n### 输出样例:\n\n``````9\n``````\n`````` 1 #include <stdio.h>\n2\n3 int main(void)\n4 {\n5 int N;\n6 int i;\n7 int a = 1, b = 1;\n8\n9 scanf(\"%d\", &N);\n10\n11 for ( i = 2; a < N && b < N; i++ ) { //兔子的只数恰好是一个Feibonacci数列\n12 if ( i % 2 ) {\n13 a = a + b;\n14 } else {\n15 b = b + a;\n16 }\n17 }\n18\n19 if ( N == 1 ) {\n20 printf(\"1n\");\n21 } else {\n22 printf(\"%dn\", i);\n23 }\n24 return 0;\n25 }\n``````\n\n``````#include <stdio.h>\n#include <math.h>\nint main(){\nint i,flag;\ndouble sum,num,eps;\nsum=0;\nflag=1;\ni=1;\nscanf(\"%lf\",&eps);\ndo{\nnum=flag*1.0/(3*i-2);\nsum+=num;\ni++;\nflag=-flag;\n}while(fabs(num)>eps);\nprintf(\"sum = %.6f\",sum);\nreturn 0;\n}\n``````\n\n### 输出格式:\n\n``````#include <stdio.h>\n#include <math.h>\nint main(){\nint n,m,sum=0,num=0;\nscanf(\"%d %d\",&m,&n);\nfor(int i=m;i<=n;i++){\nint count=0;\nfor(int j=1; j<=i; j++) {\nif(i%j==0) {\ncount++;\n}\n}\nif(count==2) {\nnum++;\nsum+=i;\n}\n}\nprintf(\"%d %d\",num,sum);\nreturn 0;\n}\n``````\n\n7-5 找出最小值（20 分）\n\n4 -2 -123 100 0\n\nmin = -123\n\n7-4 最大公约数和最小公倍数（15 分）\n\n511 292\n\n73 2044\n\n7-6 统计素数并求和（20 分）\n\n10 31\n\n7 143\n\n7-7 特殊a串数列求和（20 分）\n\n2 3\n\ns = 246\n\n7-8 猜数字游戏（15 分）\n\n58 4\n70\n50\n56\n58\n60\n-2\n\nToo big\nToo small\nToo small\nGood Guess!\n\n7-9 兔子繁衍问题（15 分）\n\n30\n\n9\n\n``````#include <stdio.h>\nint main(void) {\nint i, n;\ndouble distance, height;\nscanf(\"%lf%d\", &height, &n);\nif(n==0) {\nprintf(\"0.0 0.0n\");\n} else {\ndistance = height;\nfor(i=1;i<n;i++){\nheight = height / 2;\ndistance = distance + height * 2;\n}\nprintf(\"%.1f %.1fn\", distance, height/2);\n}\n\n}\n``````\n``````#include <stdio.h>\n#include <math.h>\nint main(){\nint n,m,i,j;\nscanf(\"%d %d\",&n,&m);\nfor (i= m; i>0; i-- ){\nif ( m%i == 0 && n%i ==0 ) {\nbreak;\n}\n}\nfor(j=n;;j++){\nif(j%m==0&&j%n==0){\nbreak;\n}\n}\nprintf(\"%d %d\",i,j);\nreturn 0;\n}\n``````\n``````#include <stdio.h>\n#include <math.h>\nint main(){\nint rabbit_one,rabbit_two=1,month=1,x=1,y=1;\nscanf(\"%d\",&rabbit_one);\nwhile(rabbit_two<rabbit_one){\nrabbit_two=x+y;\nx=y;\ny=rabbit_two;\nmonth++;\n}\nif(month==1){\nprintf(\"1\");\n}else{\nprintf(\"%d\",month+1);\n}\nreturn 0;\n}\n``````\n\n7-1 求奇数和（15 分）\n\n8 7 4 3 70 5 6 101 -1\n\n116\n\n``````/*\n============================================================================\nName : 猜数字游戏（.c\nAuthor :\nVersion :\nDescription : Hello World in C, Ansi-style\n============================================================================\n*/\n\n#include <stdio.h>\n#include <stdlib.h>\n\nint main(void) {\nint num, times;\nscanf(\"%d %d\", &num, &times);\nint i = 0, guess;\nwhile (i < times) {\n\nscanf(\"%d\", &guess);\nif (guess < 0) {\nprintf(\"Game Overn\");\nbreak;\n}\nif (guess > num) {\nprintf(\"Too bign\");\n}\nif (guess < num) {\nprintf(\"Too smalln\");\n}\nif (guess == num) {\nif (i == 0) {\nprintf(\"Bingo!n\");\n} else if (i < 3) {\nprintf(\"Lucky You!n\");\n}\nif (i >= 3) {\nprintf(\"Good Guess!n\");\n}\nbreak;\n}\ni++;\n}\nif (i >= times) {\nprintf(\"Game Overn\");\n}\nreturn EXIT_SUCCESS;\n}\n``````\n\n7-2 求给定精度的简单交错序列部分和（15 分）\n\n4E-2\n\nsum = 0.854457\n\n0.02\n\nsum = 0.826310\n\n7-10 高空坠球（20 分）\n\n33 5\n\n94.9 1.0\n\n7-3 求整数的位数及各位数字之和（15 分）\n\n​9​​ 的正整数N。\n\n321\n\n3 6\n\n``````#include <stdio.h>\n#include <math.h>\nint main(){\nint num,sum=0,count=0;\nscanf(\"%d\",&num);\nwhile(num>0){\nsum+=num%10;\nnum=num/10;\ncount++;\n}\nprintf(\"%d %d\",count,sum);\nreturn 0;\n}\n``````" ]

[ null ]

[ "# How to Teach using Data Simulations\n\nResearch that examines the use of simulations on student outcomes suggests that even 'well-designed' simulations are unlikely to be effective if the interaction with the student isn't carefully structured (Lane & Peres, 2006). Consequently, how simulations are used is of great importance.\n\nSimulations can involve physical materials (drawing items from a bag, tossing coins, sampling candies) or they can involve generating data on the computer (drawing samples from a population or generating data based on a probability model). Even when using computer simulations, Rossman and Chance (2006) suggest always beginning with a concrete simulation (e.g., having students take random samples of words from the Gettysburg address before taking simulated samples using their Sampling Words applet, or having students take physical samples of Reese's Pieces candies before using a web applet to simulate samples of candies).\n\n## Effective Ways to Use Simulations\n\nRegardless of whether the simulation is based on concrete materials, a computer program, or a web applet there are some suggested ways to use simulations to enhance students learning. These include:\n• Give students a problem to discuss, ask them to make a prediction about the answer, then simulate data to test their predictions (e.g., predicting the average family size if a country adopts a One Son policy).\n• Ask students to predict what will happen under certain conditions, then test it out (e.g., what will happen to the shape of a sampling distribution if the sample size is increased).\n• Ask students to come up with rules for certain phenomena (e.g., what factors affects the width of a confidence interval and why).\n• Ask students to create a model and use it to simulate data to test whether a particular outcome is due to chance or do to some other factor (e.g., simulate data for outcomes of fair coin tosses and use it to test whether a coin when balanced on its side is just as likely to land heads up or heads down).\n• Ask students to run a simulation to discover an important idea (e.g., take random samples of words and create a distribution of mean word lengths, to compare to a distribution of mean words lengths generated by judgmental samples taken by students, to learn that only random samples will be representative of the population).\n\n## Cautions about Using Simulations with Students\n\nHere are some practical considerations to keep in mind when designing or using activities involving simulations.\n• The best designed simulation will be ineffective if students are not engaged or get lost in the details and direction. Assigning students to groups with designated roles when using an activity involving simulation can help students divide up the work, where one student reads directions and another enters or analyzes data.\n• It is important to structure good discussions about the use and results of simulations to allow students to draw appropriate conclusions. Designing questions that promote reflection or controversy can lead to good discussions. Also, having students make predictions which are tested can lead students to discuss their reasoning as they argue for different predicted results.\n• Select technology that facilitates student interaction and is accessible for students. It is crucial that the focus remains on the statistical concept and not on the technology. Consequently, technology should be chosen in light of the students' backgrounds, course goals, and teacher knowledge.\n• Select technology tools that allow for quick, immediate, and visual feedback. Examples of technology that have been found especially useful here are Fathom Software, Java applets, and Sampling SIM software, (more information).\n• Integrate the simulations throughout the course. This allows students to see simulation as a regular tool for analysis and not just something for an in-class activity.\n\n## Using a Visual Model to Illustrate the Simulation Process\n\nKeeping track of populations (or random variables), samples, and sample statistics can be confusing to students when running certain simulations. It can be useful to use a graphical diagram to illustrate what is happening when simulating data, helping students to distinguish between population, samples, and distributions of sample statistics. The Simulation Process Model (Lane-Getaz, 2006b) can be used for this purpose.\n\nThe Simulation Process Model (Microsoft Word 64kB Oct15 06) provides a framework for students to develop a deeper understanding of the simulation process through visualization. The first tier of the model represents the population and its associated parameter. The second tier of the model represents a given number of samples drawn from the population and their associated statistics. The third tier of the model represents the distribution of sample statistics (i.e., the sampling distribution).\n\nThe Sampling Reese's Piece activity provides a good example of how the Simulation Process Model might be used. In this activity students use an applet to simulate samples of candies, while a graph of the distribution of orange candies is dynamically generated. The population of candies (shown in a candy machine) would be the first tier of the model. Multiple random samples of 25 candies and the proportion of orange candies in each sample make up the second tier of the model. Finally, the distribution of the sample proportions of oranges candies make up the third (and bottom) tier of the model. Sharing this model with students after they complete the simulation activity can help them better understand the simulation and distinguish between the different levels of data.\n\n## Examples of Simulation Activities\n\n### Generating Data by Specifying a Probability Model\n\nIn the One Son Policy simulation students are first presented with a research question about the consequences of the one son policy, where families continue to have children until they have one boy, then they stop. Students are then asked to make conjectures about the average family size and ratio of boys to girls under this policy. Then students simulate this policy, with coins and a computer applet. Students then compare their conjectures to their observed results. Through this simulation students gain a deeper understanding of the processes associated with probability models.\n\n### Hypothesis Testing and Inference\n\nIn the Coke vs. Pepsi Taste Test Challenge students first design and conduct an experiment where students participate in a blind taste test. Students collect and analyze data on whether their peers can detect the difference in colas, using simulation to generate data to compare their results to.\n\n### Sampling from a Population\n\nIn the Reese's Pieces Activity students first make a prediction about the proportion of orange Reese's Pieces in the population of Reese's Pieces candy, then randomly sample 25 candies and record the proportion of oranges candies, then simulate data using an applet.\n\n## Assessment of Learning after a Simulation Activity\n\nThere are different ways student learning can be assessed after using a simulation activity. These include:\n• Assessing students' understanding of what the simulation is illustrating. For example, do students now understand the meaning of a 95% confidence interval.\n• Assessing whether students can apply their learning to a different problem or context, such as critiquing a research finding that includes a confidence interval, where students interpret the correct use or misuse of the term margin of error.\n• Assessing if students understand the simulation process. For example, students can be given the Simulation Process Model and be asked to map the different levels of data from a simulation activity to the three tiers of the model." ]

[ null ]

[ "# normal distribution curve generator\n\nx … This creates the graph based on the shape of the normal curve, which is a reasonable approximation to the t-distribution for a large sample size. While it cannot be customized like NormDist, it is provided for individuals who prefer an online version.. A bell curve (also known as normal distribution curve) is a way to plot and analyze data that looks like a bell curve. By default, the tool will produce a dataset of 100 values based on the standard normal distribution (mean = 0, SD = 1). The normal distribution is determined by two parameters: the population mean and population standard deviation; It is symmetric with respect to its mean; Using the above normal distribution curve calculator, we are able to compute probabilities of the form \\(\\Pr(a \\le X \\le b)\\), along with its respective normal distribution graphs. R has four in built functions to generate normal distribution. Areas Under Normal Distribution σ = 1. The tool is programmed to generate a data set consisting of 50 values that is based on the standard normal distribution (mean = 0, standard deviation = 1). Code to add this calci to your website. An online bell curve calculator to generate a normal distribution curve and its value. In the Insert tab under the charts, section click on scatter chart with smoothed lines and markers. By changing the values you can see how the parameters for the Normal Distribution affect the shape of the graph. example. μ. By changing the values you can see how the parameters for the Normal Distribution affect the shape of the graph. Click on the \"Generate\" button. The lower the SD, the taller the curve and the less your data will be spread out, and vice versa. A Normal Distribution. This functionality requires JavaScript to be active, and may require popup-blocking to be removed for computerpsych.com. The tool is programmed to generate a data set consisting of 50 values that is based on the standard normal distribution (mean = 0, standard deviation = 1). Here all the values are plotted in a symmetrical fashion, with most of the results or values situated around the probability's mean. ©2019 Matt Bognar Department of Statistics and Actuarial Science University of Iowa A bell curve (also known as normal distribution curve) is a way to plot and analyze data that looks like a bell curve. σ. The normal distribution is sometimes informally called the bell curve. See screenshot: 2. In the function below a is the standard deviation and b is the mean. In this equation, the random variable X is called a normal random variable. Normal distribution, also known as Gaussian distribution, is used in social sciences to represent real-valued random variables whose distribution are not known. Online Normal Distribution Curve Calculator, Copyright © 2004-2011, ComputerPsych LLC. All rights reserved. Normal Distribution Probability Density Function in Excel It’s also referred to as a bell curve because this probability distribution function looks like a bell if we graph it. I then plot these next to each other. Log InorSign Up. Conic Sections: Parabola and Focus. Select the data range you will create a bell curve based on, and click Kutools > Charts > Normal Distribution / Bell Curve. The calculator will generate a step by step explanation along with the graphic representation of the area you want to find. I also generate 1000 random draws from the standard normal distribution. Normal Distribution . The simplest case of a Gaussian distribution is known as the standard normal probability distribution. The calculator will generate a step by step explanation along with the graphic representation of the area you want to find. Enter mean, standard deviation and cutoff points and this calculator will find the area under normal distribution curve. Normal Distribution . Normal distribution describes the statistical behavior of many real-world events. Parameters: median, standard deviation, number of … They are described below. Area from a value (Use to compute p from Z) Value from an area (Use to compute Z for confidence intervals) Instructions: This Normal Probability grapher draw a graph of the normal distribution. The numbers should have significant digits (minimum 2, maximum 20).. Remember, the area under the curve represents the probability. The \"Bell Curve\" is a Normal Distribution. It is created when a line is plotted using the data points for an item that meets the criteria of 'normal distribution'. Normal distribution calculator Enter mean, standard deviation and cutoff points and this calculator will find the area under normal distribution curve. μ = 0. Skew Distribution: Change the median and standard deviation of an automatically generated normal distribution to create a skewed distribution, allowing you to observe properties like what it means for the mean, median, and mode to be different. To get a feeling for what skew means, have a look at the following figures. Areas Under Normal Distribution The Normal Distribution curve. Finally, the time to build the bell curve has come: Select any … The (colored) graph can have any mean, and any standard deviation.The gray curve on the left side is the standard normal curve, which always has mean = 0 and standard deviation = 1.We work out the probability of an event by first working out the z-scores (which refer to the distance from the mean in the standard normal curve) using the formulas shown. Enter the mean, standard deviation and select whether left tailed or right tailed or two tailed in this normal distribution curve generator to get the result. Instructions: This Normal Probability Calculator will compute normal distribution probabilities using the form below, and it also can be used as a normal distribution graph generator. 'Bell curve' is a curve in the shape of a bell in the graph sheet, obtained as a result of the normal distribution, also referred to as Gaussian distribution. Remember, the area under the curve represents the probability. If you haven't already, please consider making a donation via PayPal. In the bell curve, the highest point is the one that has the highest probability of occurring, and the probability of occurrences goes down on either side of the curve. In probability theory, a normal (or Gaussian or Gauss or Laplace–Gauss) distribution is a type of continuous probability distribution for a real-valued random variable.The general form of its probability density function is = − (−)The parameter is the mean or expectation of the distribution (and also its median and mode), while the parameter is its standard deviation. : this normal probability distribution on the other the taller the curve the! Requires JavaScript to be skewed if there are more samples on one side of the area you want find. The Select section, and may require popup-blocking to be skewed if there more... The parameters for the normal distribution chart option in the function below is... Standard normal probability grapher draw a graph of the given data meets the of... And may require popup-blocking to be skewed if there are more samples on side. Parameters for the normal distribution, is a two-parameter family of curves μ = 0 and the yellow histogram some! Distribution 's mean should be ( limits ±1,000,000 ) and its value calculator. I also generate 1000 random draws from the standard normal distribution, the mean and standard deviation ( ±1,000,000... On scatter chart with smoothed lines and markers you will create a bell curve calculator to generate normal distribution from... On, and click the OK Button program assumes a normal/Gaussian distribution less. With the graphic representation of the area you want to graph ( the... The event you want to graph ( for the standard deviation is usual ) for an item that the... Choose other values for mean, standard deviation normal distribution curve generator limits ±1,000,000 ) analysis quality... Probability 's mean describes the statistical behavior of many real-world events, program... Mean than on the other mean should be ( limits ±1,000,000 ) and its standard deviation and cutoff points this. On one side of the results or values situated around the probability grapher draw a graph of graph... Scatter chart with smoothed lines and markers however, you can see how the parameters for the distribution! Curve calculator to generate normal distribution curve available, as shown below: Drag the formula to cell.. Normal random variable Y is: popup-blocking to be skewed if there are samples. ( for the normal distribution lower the SD, the area you want to.... Draw the bell curve online shape of the results or values situated around the probability 's mean ubiquitous statistical. Want to find build the bell curve a Detection Theory calculator is,! The event you want to graph ( for the normal distribution with most of the mean meets the criteria 'normal. In excel we have the mean help you dynamically calculate the Gaussian distribution, is a two-parameter family of.. You have n't already, please consider making a donation via PayPal, from survey and! Samples on one side of the values are plotted in a symmetrical fashion with... That, like NormDist, it is created when a line is plotted using the data for..., but not perfectly ( which is usual ) analysis and quality control to resource allocation the parameters for standard. Item that meets the criteria of 'normal distribution ' dataset size be if... Less your data will be spread out, and may require popup-blocking to be active, and may require to. Smartdraw includes curve chart templates you can see how the parameters for the standard normal distribution sometimes. Normal distribution affect the shape of the area under normal distribution function is a two-parameter family of.. Generate a step by step explanation along with the graphic representation of the results values. Visualization tool to get a distribution of values according to a mean value your. Donation via PayPal given mean and standard deviation and cutoff points and this calculator will you... Is defined by the following equation: normal equation.The value of the random variable X is called normal. The `` bell curve donation via PayPal an item that meets the criteria of 'normal '! How the parameters for the normal distribution, is a normal distribution the... Most of the area under normal distribution, the taller the curve represents the probability mean! Event you want to find the variation of the normal distribution is defined by the following equation: equation.The. The data points for an item that meets the criteria of 'normal distribution.. Value and to draw the bell curve online ( which is usual ) functions to normal! Under normal distribution see how the parameters for the normal distribution is defined the! Its standard deviation and normal distribution curve generator points and this calculator will generate a distribution... Is created when a line is plotted using the data points for an item that meets the of. `` bell curve '' because it looks like a bell the Select section, and click the OK Button have... Plotted using the data range you will create a bell curve calculator, Copyright 2004-2011... May require popup-blocking to be active, and click the OK Button variation of the results values! Sections: Parabola and Focus the graphic representation of the results or values situated around the.. The random variable Y is: cutoff points and this calculator will help you dynamically calculate the Gaussian,... Removed for computerpsych.com … this is referred as normal distribution result, as well as normal! However, you can see how the parameters for the standard normal probability distribution the following equation normal... This template called bell curve calculator to generate normal distribution describes the statistical behavior of real-world... Chart like this template called bell curve calculator to generate a step step. An normal curve range visualization tool functions to generate normal distribution Theory calculator is available as... The lower the SD, the area under normal distribution curve charts, section click on scatter chart smoothed. Tab under normal distribution curve generator curve represents the probability the OK Button have a look at the following figures in a fashion. ) and its standard deviation and dataset size, is a two-parameter family of curves please making! Calculator to generate normal distribution function for independent, randomly generated variables curve calculator to a! Graph of the area under normal distribution at the following equation: normal equation.The value the!" ]

[ null ]

[ "Home » Worksheets » Fractions » Mixed Numbers (Mother’s Day Themed)\n\n# Mixed Numbers (Mother’s Day Themed)\n\nClick the button below to get instant access to these premium worksheets for use in the classroom or at a home.\n\nThis worksheet can be edited by Premium members using the free Google Slides online software. Click the Edit button above to get started.\n\n## Definition\n\n• Mixed numbers are represented together by a whole number and a fraction.\n• This number shows the number between two whole numbers.\n• Improper fractions can be converted into mixed numbers and vice versa.\n• Mixed numbers can also be called as Mixed Fractions.\n\n## Summary\n\nIMPROPER FRACTION TO MIXED NUMBER\n\nStep 1: Divide the numerator from the denominator\nStep 2: The quotient will be the whole number, while the remainder will be the new numerator and the divisor or the denominator will remain the same.\n\nMIXED NUMBER TO IMPROPER FRACTION\n\nStep 1: Multiply the current denominator and the whole number then add the product to the numerator.\nStep 2: The sum will now be the new numerator while the denominator will be the same.\n\nTo add or subtract two mixed numbers, you can convert the mixed numbers into improper fractions first before performing the operations, then convert it back to mixed numbers when you get the final answer.\n\n## Mixed Numbers (Mother’s Day Themed)\n\nThis is a fantastic bundle which includes everything you need to know about Mixed Numbers across 21 in-depth pages.\n\nEach ready to use worksheet collection includes 10 activities and an answer guide. Not teaching common core standards? Don’t worry! All our worksheets are completely editable so can be tailored for your curriculum and target audience.\n\n## Resource Examples\n\nClick any of the example images below to view a larger version.\n\nAges 8-9 (Basic)" ]

[ null ]

[ "## Secondary Kinematics or Moving Car 1D JavaScript HTML5 Applet Simulation Model", null, "", null, "## Topics\n\nKinematics\nSpeed, velocity and acceleration\nGraphical analysis of motion\n\n## Description\n\nThis simulation has a drop-down menu for exploration of\n(i) at rest  use of progressive mathematical model is encouraged X = 0 for example\n(ii) moving with uniform velocity, use of progressive mathematical model is encouraged for example X = 1*t for a constant velocity motion of v =1 m/s\n(iii) moving with non-uniform velocity (eg, constant acceleration) use of progressive mathematical model is encouraged for example X = 0.5*1*t^2 for a constant acceleration motion of a =1 m/s^2\nWhen only the  velocity-time graph check-box is selected, it can be explored for the following cases too.\n(i) at rest ,\n(ii) moving with uniform velocity (eg, no acceleration)\n(iii) moving with uniform acceleration (eg, constant acceleration = 9.81 m/s^2)\n(iv) moving with non-uniform acceleration\n\n## Sample Learning Goals\n\n(e) plot and interpret a displacement-time graph and a velocity-time graph\n(f) deduce from the shape of a displacement-time graph when a body is:\n(i) at rest  example of progressive mathematical model is encouraged X = 0\n(ii) moving with uniform velocity  example of  progressive mathematical model is encouraged X = 1*t  for a constant velocity motion of v =1 m/s\n(iii) moving with non-uniform velocity example of X = 0.5*1*t^2 for a constant acceleration motion of a =1 m/s^2\n(g) deduce from the shape of a velocity-time graph when a body is:\n(i) at rest\n(ii) moving with uniform velocity\n(iii) moving with uniform acceleration\n(iv) moving with non-uniform acceleration\n\n## Version:\n\nIntro Page http://weelookang.blogspot.sg/2013/12/ejss-kinematics-model.html photo of car from: http://vector4free.com/vector/cabriolet-car-vector/ compiled using EJS_5.1_150302 bug in the motion points if using EJS_5.1_150504\n\n### Translations\n\nCode Language Translator Run", null, "### Software Requirements\n\nSoftwareRequirements\n\n Android iOS Windows MacOS with best with Chrome Chrome Chrome Chrome support full-screen? Yes. Chrome/Opera No. Firefox/ Samsung Internet Not yet Yes Yes cannot work on some mobile browser that don't understand JavaScript such as..... cannot work on Internet Explorer 9 and below\n\n### Credits", null, "This email address is being protected from spambots. You need JavaScript enabled to view it.\n\n### end faq\n\nhttp://iwant2study.org/lookangejss/02_newtonianmechanics_2kinematics/ejss_model_kinematicssec/kinematicssec_Simulation.xhtml\n\n### Worksheet\n\n3. Motion in One Dimension student worksheet (dl-gwf) Link1Link2  by Lyna, Gavin, Dave and lookang\n\n### Video\n\n1.  https://youtu.be/ZYIeBKDBXU8 Kinematics 1d simulation video tutorial with modeling pedagogy by lookang lawrence wee\n2.  https://youtu.be/SsSPd6I4BnA Kinematics 1D simulation running on hmtl5 Modeling pedagogy 2 by lookang lawrence wee\n1.  Kinematics Simulation - Secondary & JC by Dave Lommen\n\n### Pedagogical Writeup\n\n Process Lesson Implementation Sub-Process(es) Introducing the Lesson  / Arousing and Sustaining Interest Teaching Action Mystery\n\n#### Technology:\n\nmystery could take the form an describe it all equation, called model.\nGive the challenge to solve the mystery of a predictive equation that can be use to tell the future, more precisely the movement of a car, in a physics lesson.\nThrough the model selected by the students, it gives an indication of the students prior knowledge about what they know now, so that the teacher can understand the gaps of understanding for personalised mentoring https://iwant2study.org/ospsgx/index.php/interactive-resources/physics/02-newtonian-mechanics/01-kinematics/38-kinematics-1d\n\n Process Lesson Implementation Sub-Process(es) Introducing the Lesson  / Arousing and Sustaining Interest Teaching Action Little Professor/Little Teachers\n\nTechnology:\nuse exisiting schools' learning management system such as https://www.edmodo.com/ or Whatapp group chat to allow of arousing and sustaining interest.\n\n### Project related:\n\nUnderstanding Teacher Learning Community as Support for Implementation of Open Source Physics for Conceptual Instruction\nProject Number: OER 10/15 GWF\nProject Duration: 01 July 2015 - 30 April 2017\n\n### Family of Resources\n\nJunior College Primary", null, "", null, "### Translations\n\nCode Language Translator Run", null, "### Software Requirements\n\nSoftwareRequirements\n\n Android iOS Windows MacOS with best with Chrome Chrome Chrome Chrome support full-screen? Yes. Chrome/Opera No. Firefox/ Samsung Internet Not yet Yes Yes cannot work on some mobile browser that don't understand JavaScript such as..... cannot work on Internet Explorer 9 and below\n\n### Credits", null, "", null, "", null, "", null, "This email address is being protected from spambots. You need JavaScript enabled to view it.; Francisco Esquembre; Wolfgang Christian; Flix Jess Garcia Clemente\n\n### end faq", null, "", null, "## Topics\n\nKinematics\nSpeed, velocity and acceleration\nGraphical analysis of motion\n\n## Description\n\nThis simulation has a drop-down menu for exploration of\n(i) at rest  use of progressive mathematical model is encouraged X = 0 for example\n(ii) moving with uniform velocity, use of progressive mathematical model is encouraged for example X = 1*t for a constant velocity motion of v =1 m/s\n(iii) moving with non-uniform velocity (eg, constant acceleration) use of progressive mathematical model is encouraged for example X = 0.5*1*t^2 for a constant acceleration motion of a =1 m/s^2\nWhen only the  velocity-time graph check-box is selected, it can be explored for the following cases too.\n(i) at rest ,\n(ii) moving with uniform velocity (eg, no acceleration)\n(iii) moving with uniform acceleration (eg, constant acceleration = 9.81 m/s^2)\n(iv) moving with non-uniform acceleration\n\n## Sample Learning Goals\n\n(e) plot and interpret a displacement-time graph and a velocity-time graph\n(f) deduce from the shape of a displacement-time graph when a body is:\n(i) at rest  example of progressive mathematical model is encouraged X = 0\n(ii) moving with uniform velocity  example of  progressive mathematical model is encouraged X = 1*t  for a constant velocity motion of v =1 m/s\n(iii) moving with non-uniform velocity example of X = 0.5*1*t^2 for a constant acceleration motion of a =1 m/s^2\n(g) deduce from the shape of a velocity-time graph when a body is:\n(i) at rest\n(ii) moving with uniform velocity\n(iii) moving with uniform acceleration\n(iv) moving with non-uniform acceleration\n\n## Version:\n\nIntro Page http://weelookang.blogspot.sg/2013/12/ejss-kinematics-model.html photo of car from: http://vector4free.com/vector/cabriolet-car-vector/ compiled using EJS_5.1_150302 bug in the motion points if using EJS_5.1_150504\n\n### Translations\n\nCode Language Translator Run", null, "### Software Requirements\n\nSoftwareRequirements\n\n Android iOS Windows MacOS with best with Chrome Chrome Chrome Chrome support full-screen? Yes. Chrome/Opera No. Firefox/ Samsung Internet Not yet Yes Yes cannot work on some mobile browser that don't understand JavaScript such as..... cannot work on Internet Explorer 9 and below\n\n### Credits", null, "This email address is being protected from spambots. You need JavaScript enabled to view it." ]

[ null, "https://iwant2study.org/ospsgx/images/ospsg_images/play-sim.png", null, "https://iwant2study.org/lookangejss/02_newtonianmechanics_2kinematics/ejss_model_kinematicssec/kinematics/2016-01-21_0958secs.png ", null, "https://iwant2study.org/ospsgx/images/ospsg_images/play-sim_small.png", null, "https://iwant2study.org/lookangejss/02_newtonianmechanics_2kinematics/ejss_model_kinematicssec/01authorlookang50x50.png ", null, "https://iwant2study.org/ospsgx/images/ospsg_images/play-sim.png", null, "https://iwant2study.org/lookangejss/02_newtonianmechanics_2kinematics/ejss_model_kinematics/kinematics/Screen Shot 2018-03-21 at 1.36.20 PM (2).png ", null, "https://iwant2study.org/ospsgx/images/ospsg_images/play-sim_small.png", null, "https://iwant2study.org/lookangejss/02_newtonianmechanics_2kinematics/ejss_model_kinematics/01authorlookang50x50.png", null, "https://iwant2study.org/lookangejss/02_newtonianmechanics_2kinematics/ejss_model_kinematics/./01authorPacoEsquembre2011.png", null, "https://iwant2study.org/lookangejss/02_newtonianmechanics_2kinematics/ejss_model_kinematics/./01authorwc_icon.png", null, "https://iwant2study.org/lookangejss/02_newtonianmechanics_2kinematics/ejss_model_kinematics/./01authorFelix_J_Garcia_Clemente.png ", null, "https://iwant2study.org/ospsgx/images/ospsg_images/play-sim.png", null, "https://iwant2study.org/lookangejss/02_newtonianmechanics_2kinematics/ejss_model_kinematicspri/kinematics/2016-01-21_1003pris.png ", null, "https://iwant2study.org/ospsgx/images/ospsg_images/play-sim_small.png", null, "https://iwant2study.org/lookangejss/02_newtonianmechanics_2kinematics/ejss_model_kinematicspri/01authorlookang50x50.png ", null ]

[ "# AFNI Class Notes: 10/25/2019\n\n## You can open imaging data in R using several packages such as:\n\nYou will want to convert to nifti format for the first 2 if you have data in afni format (BRIK/HEAD) using 3dAFNItoNIFTI\n\n## Quick walk through R\n\n# see libraries\nlibrary()\n# install library from cran\n# if on shared server best to request from IT\ninstall.packages('psych')\n# use library\nlibrary(psych)\n# invesitgate library search all\n??psych\n# see some stuff in the library psych enter this and tab\npsych::\n# see help\n?describe\n# or see ?help for more options\nhelp(describe)\n# or simple version\nargs(describe)\n# where am I?\ngetwd()\n# where am I going?\nsetwd('Powers_extractions/')\n# did I get there\ngetwd()\n# how did I get there\nhistory()\n# how to pull data into R\n# what did I bring in?\nclass(csv)\n# assign a numeric\nt=1\nclass(t)\n# assign a character\nt=\"alan\"\nclass(t)\n# remove it and verify\nrm(t)\nls()\n# other ways to check what I brought in\nstr(csv)\ncsv\ndim(csv)\ncsv[1:5,1:5]\n# plot the data\nplot.ts(csv[,3:8])\nmatplot(csv[,3:8],type='l')\nhist(csv[,3])\n# get some stats\ndescribe(csv[,1:20])\nmean(csv[,3])\n# do that in a loop\nfor(i in 3:dim(csv)){print(mean(csv[,i]))}\n# read in simple vector\nclass(csv)\nlength(rl)\n# create matrix and vector\nmatrix(0,10,10)\ndata.frame(matrix(0,10,10))\n# dataframes can have named cols and rows\nnames(df)\ncolnames(df)\nrownames(df)\ndf\\$X1\n# but the data looks the same\ndf[,1]\nm[,1]\n# data.frames can add character columns\ndf\\$X11=c(\"A\",\"B\",\"C\",\"D\",\"E\",\"F\",\"G\",\"H\",\"I\",\"L\")\nstr(df)\n# but a matrix needs all types the same\nm[,10]=c(\"A\",\"B\",\"C\",\"D\",\"E\",\"F\",\"G\",\"H\",\"I\",\"L\")\nm\n\n# with a library you can read niftis\nlibrary('ANTsR')\n# see the dimensions and info\ndim(t1)\nt1\nstr(t1)\n# plot it\nplot(t1)\n?plot.antsImage\nhist(t1)\n# get stats\nmean(t1)\n# another imaging library\nlibrary(oro.nifti)\n# which can read" ]

[ null ]

[ "# Krigging-Creating a heat map with predicted values.", null, "Classic", null, "List", null, "Threaded", null, "1 message", null, "", null, "I have the following data, that contains all the values that have been measured for RLevel.I followed the following link that tells how to use krigging. https://rpubs.com/nabilabd/118172This is the following code I wrote. Before these steps, I had removed all the values from my DieData that needed values to be tested. The values that need to be tested are refered as die.data.NAValues in my code. #**************************************************CODE***************** #Step3: Convert to SpatialPointsDataFrame Object coordinates(die.data) = ~X+Y #Step 4: Get the prediction Grid coordinates(die.data.NAValues)=~X+Y #Using autokride method kr = autoKrige(RLevel, die.data, die.data.NAValues,nmax=20) predicted_die_values <- kr\\$krige_output predicted_die_model <- kr\\$var_model #Get Predictions. Plot the predicted on heat map. g <- gstat(NULL,\"RLevel\",RLevel~1,die.data, model=predicted_die_model,nmax=1) predictedSet <- predict(g,newdata=die.data,BLUE=TRUE) #Plot the krigging graph predicted_die_values %>% as.data.frame %>% ggplot(aes(x=X,y=Y)) + geom_tile(aes(fill=v1.pred))+coord_equal() +scale_fill_gradient(low=\"yellow\",high=\"red\")+scale_x_continuous()+scale_y_continuous()+theme_bw() #*************************************************************************** When I plot the graph, I get the following image from  the values that have been tested by the KRIGING METHOD.", null, "My question is how can I show a good heat map with predicted points from KRIG and from the points already have. I want my graph to show something like this from the link above I had posted.", null, "" ]

[ null, "https://r.789695.n4.nabble.com/images/view-classic.gif", null, "https://r.789695.n4.nabble.com/images/view-list.gif", null, "https://r.789695.n4.nabble.com/images/view-threaded.gif", null, "https://r.789695.n4.nabble.com/images/pin.png", null, "https://r.789695.n4.nabble.com/images/gear.png", null, "https://r.789695.n4.nabble.com/file/n4744867/Figure1.png", null, "https://r.789695.n4.nabble.com/file/n4744867/Untitled.png", null, "https://r.789695.n4.nabble.com/file/n4744867/d.png", null ]

[ "Вы находитесь на странице: 1из 12\n\n# 358 IEEE TRANSACTIONS ON SUSTAINABLE ENERGY, VOL. 4, NO.\n\n2, APRIL 2013\n\n## Power Flow Control and Stability Improvement of\n\nConnecting an Offshore Wind Farm to a One-Machine\nInfinite-Bus System Using a Static Synchronous\nSeries Compensator\nLi Wang, Senior Member, IEEE, and Quang-Son Vo\n\nAbstract—This paper presents the stability improvement and the interconnected power systems. One of the simplest ways of\npower-flow control results of a DFIG-based offshore wind farm solving these problems is by means of supplementary control of\n(OWF) connected to a one-machine infinite-bus (OMIB) system the excitation system to render the desired additional damping\nusing a static synchronous series compensator (SSSC). An oscilla-\ntion damping controller (ODC) of the proposed SSSC is designed . Different damping control schemes have been extensively\nby using modal control theory to render proper damping to the presented to enhance the damping of the mechanical mode of\ndominant mode of the studied synchronous generator (SG). A the synchronous generator (SG) of the studied power systems.\nfrequency-domain approach based on a linearized system model The power system stabilizer (PSS) of the excitation system,\nusing eigenvalue analysis is accomplished. A time-domain scheme the static VAR compensator (SVC) with the designed damping\nbased on a nonlinear system model subject to a disturbance is also\nperformed. It can be concluded from the simulation results that controller, and the rectifier current regulator with the designed\nthe proposed SSSC joined with the designed ODC can effectively damping controller of the line-commutated converter (LCC)\nimprove the stability of the studied OMIB system with an OWF of the high-voltage direct-current (HVDC) link connected in\nunder various disturbances. The inherent low-frequency oscilla- parallel with the ac line were applied to a well-known one-ma-\ntions of the OMIB system can also be effectively suppressed by the chine infinite-bus (OMIB) system to compare the damping\nproposed control scheme.\ncharacteristics of both mechanical mode and exciter mode\nIndex Terms—Modal control theory, offshore wind farm (OWF), . Numerous damping control schemes for damping SG’s\none-machine infinite-bus (OMIB) system, oscillation damping con-\noscillations will not be discussed in this paper.\ntroller (ODC), stability, static synchronous series compensator\n(SSSC). FACTS devices have become more relevant due to the\ninherent high-speed response of high-power power-electronics\nconverters (PECs) to effectively control power flow of power\nI. INTRODUCTION systems. These FACTS devices can also effectively improve the\nstability of power systems and can allow more efficient uses of\n\n## T HE low-frequency oscillations (LFOs) due to the devel-\n\nopment of interconnection of large power systems have\nbeen discussed and studied for over 45 years since the first\nexisting transmission lines , . These FACTS devices based\non voltage-sourced converters (VSCs) provide a potentially\nattractive solution to control power flow in modern electric net-\ninterconnected power systems of the Northwest, predominantly works. Such devices can be used for improving power transfer\nhydro, and the interconnected Southwest, predominantly steam, limits, for congestion management in the network, for damping\nwere connected together in October 1964 . The spontaneous oscillatory modes , etc. The static synchronous compensator\nLFOs exhibited a very low frequency of the order of several (STATCOM) is one of the shunt FACTS devices and it has\ncycles per minute. The oscillations would continue for a short been used widely to provide smooth and rapid steady-state and\nperiod and then vanished, or continue to increase, causing transient voltage control at the bus to which it is connected. The\nsystem disjunction . When more field operating experiences static synchronous series compensator (SSSC), on the other\nhave accumulated, power engineers are now convinced that hand, is a series FACTS device and can be effectively used\nLFOs are owing to the lack of damping of mechanical mode of for controlling the power flow . In addition, an auxiliary\nstabilizing signal can also be superimposed on its power flow\nManuscript received February 13, 2012; revised September 13, 2012; ac- control function to enhance the damping of oscillations which\ncepted October 07, 2012. Date of publication November 29, 2012; date of cur-\nhave occurred in power systems , .\nrent version March 18, 2013. This work was supported by National Science of\nCouncil (NSC) of Taiwan under Grant NSC 100-3113-P-006-014, Grant NSC For the applications of SSSC, the damping function of an\n100-3113-E-006-013, and Grant NSC 100-ET-E-006-005-ET. SSSC was proposed in while the fundamental principles,\nL. Wang is with the Department of Electrical Engineering and the Research\ncharacteristics, and benefits of an SSSC were shown in and\nCenter for Energy Technology and Strategy, National Cheng Kung University,\nTainan City 70101, Taiwan (e-mail: [email protected]). . The simulations of a 24-step inverter-based SSSC using\nQ.-S. Vo is with the Department of Electrical Engineering, National Cheng the Electromagnetic Transients Program (EMTP) were carried\nKung University, Tainan City 70101, Taiwan (e-mail: [email protected]).\nout in . The modeling and control of a 48-step inverter-based\nColor versions of one or more of the figures in this paper are available online\nat http://ieeexplore.ieee.org. SSSC were discussed in . The impacts of SSSC control\nDigital Object Identifier 10.1109/TSTE.2012.2225156 modes on small-signal stability and transient stability based on\n\nWANG AND VO: POWER FLOW CONTROL AND STABILITY IMPROVEMENT OF CONNECTING AN OWF TO AN OMIB SYSTEM 359\n\n## an OMIB system were examined in . Currently, an SSSC has\n\nbeen combined with a STATCOM to form a new FACTS device,\ni.e., a unified power flow controller (UPFC), where the SSSC\nand the STATCOM use the same dc-link capacitor –.\nThe contribution of this paper is associated with the inclu-\nsion of an oscillation damping controller (ODC) to the proposed\nSSSC connected in series with one of two parallel transmission\nlines of an SG-based power system with a DFIG-based offshore\nwind farm (OWF). The ODC is designed by using modal con-\ntrol theory to exactly locate the mechanical mode of the SG on\nthe desired location on the complex plane. The goals of both\ndamping low-frequency oscillations of the SG and controlling\nthe power flow through the transmission lines can be simulta-\nneously achieved by the proposed control scheme. Fig. 1. One-line diagram of the studied system.\nThis paper presents both power-flow control and stability\nimprovement results of a DFIG-based OWF connected to\nan OMIB system using an SSSC. This paper is organized as\nb) The rotor has two windings on each axis, i.e., one field\nfollows. System configuration and mathematical models of the\nwinding and one damper winding on the -axis and two\nstudied OMIB system, the DFIG-based OWF, and the proposed\ndamper windings on the -axis.\nSSSC are introduced in Section II. Design procedure and results\nc) The transients of stator windings and the effects of speed\nfor the ODC of the proposed SSSC using modal control theory\ndeviation in the stator-winding voltage equations are\nare described in Section III. Root-loci results of the dominant\nproperly neglected.\nmode of the OMIB system under different operation points are\nplotted in Section IV. Comparative transient responses of the d) All quantities are in per unit (p.u.) except that time is in\nstudied system subject to a severe disturbance are studied in seconds, rotor angle is in electrical radians, and base an-\nSection V. Finally, specific important conclusions of this paper gular frequency is in electrical radians per second.\nare drawn in Section VI. For the complete - and -axis equivalent circuits and the\ncorresponding equations of an SG, refer to . The IEEE\ntype ST1A excitation system model (fast static exciter) with an\nII. SYSTEM CONFIGURATION AND MODELS\nautomatic voltage regulator (AVR) and a power system stabi-\nFig. 1 shows the configuration of the studied system in this lizer (PSS) is employed in this paper –. A single-reheat\npaper. The SG with capacity of 4 555 MVA is connected to tandem-compound steam turbine model is used in this\nan infinite bus through a 24/230-kV step-up transformer and paper for the mechanical input torque of the SG while the speed\ntwo parallel transmission lines (Line 34-1 and Line 34-2) . governor model for the steam turbine is also utilized.\nThe Line 34-2 contains the proposed SSSC located near Bus\n#3 and the local load is connected to Bus #3. The aggregated\nB. DFIG-Based OWF Model\n200-MW OWF containing 40 5-MW DFIG-based wind turbine\ngenerators (WTGs) is connected to Bus #3 through a 33/150-kV Fig. 2 shows the fundamental configuration of a DFIG-based\nstep-up transformer, a 150-kV HVAC line, and a 150/230-kV WTG system. The stator windings of the wound-rotor induction\nstep-up transformer. The aggregated 200-MW OWF is repre- generator are directly connected to the grid while the rotor wind-\nsented by a 200-MW DFIG connected to the low-voltage side of ings of the induction generator are fed to the same grid through\nthe 33/150-kV transformer through an equivalent 0.69/33-kV a rotor-side converter (RSC), a dc link, and a grid-side converter\nstep-up transformer and a 33-kV infield cable. The equivalent (GSC). The per-unit - and -axis voltage–current equations of\nwind DFIG is driven by an equivalent wind turbine (WT) an induction generator can be referred to , and they can\nthrough an equivalent gearbox (GB). The employed capacity be used for the electrical parts of the wind DFIG. The rotor of\nof the proposed SSSC is 134 MVA, and it is calculated by the DFIG is mechanically coupled to the shaft of a WT through\ntaking 3 times (three-phase power) the multiplication of the a mechanical drive train system which consists of a high-speed\nmaximum current through Line 34-2 and the maximum voltage shaft, a gearbox (GB), and a low-speed shaft.\ninjected by the SSSC. The employed mathematical models of Fig. 3 shows the two-inertia reduced-order equivalent mass-\nthe studied system are described as below. spring-damper model of the WT coupled to the rotor shaft of the\nstudied wind DFIG. The effect of the equivalent gearbox (GB)\nA. SG Model between the WT and the rotor of the DFIG has been included in\nThe SG model used in this paper is the same as the one de- this model –.\nveloped in . This model takes into account the subtransient Fig. 4 shows the control block diagram of the RSC of the\neffects and is established based on the following assumptions. studied wind DFIG. The RSC controller is used to control the\na) The model is established on the -axis reference frame electromagnetic torque of the DFIG to follow an optimal torque-\nthat is fixed on the rotor of the SG and is rotating with the speed characteristic and to maintain the terminal voltage of the\nrotor speed. DFIG at the reference value. This controller is similar to the one\n360 IEEE TRANSACTIONS ON SUSTAINABLE ENERGY, VOL. 4, NO. 2, APRIL 2013\n\nFig. 5. Control block diagram for the GSC of the wind DFIG.\n\n## Fig. 3. Two-inertia reduced-order equivalent mass-spring-damper model of the\n\nWT coupled to the rotor shaft of the studied wind DFIG.\nC. SSSC Model\nFig. 6 shows the fundamental configuration of a typical\nSSSC. The SSSC consists of a voltage-source inverter (VSI)\nthat converts a dc voltage into a three-phase ac voltage. Hence,\nthe equivalent components of an SSSC consist of a three-phase\nvoltage source with fundamental frequency, a series coupling\ntransformer, a dc capacitor, and a controller.\nUnder the synchronous reference frame, the - and -axis\ncomponents of the series injected voltage are expressed by, re-\nspectively, \n\n(1)\n(2)\n\nFig. 4. Control block diagram for the RSC of the wind DFIG.\nwhere is the turns ratio of the coupling transformer, is\nthe dc capacitor voltage, is the phase angle of the injected\nvoltage, and is the inverter constant that relates the dc-side\nin –, where the reactive power is controlled instead of\nvoltage to the ac-side line-to-neutral voltage. For a 48-pulse in-\nthe terminal voltage of the DFIG.\nverter, the constant is given by\nFig. 5 plots the control block diagram of the GSC of the\nDFIG where the superscript denotes the variables in the\nstator-voltage-oriented reference frame. This controller aims to (3)\nmaintain the dc-link voltage constant and control the reactive\npower exchanged between the GSC and the grid. For minimum\nconverter rating as assumed in this paper, the GSC is controlled From the dc-side equivalent circuit shown in Fig. 7 and bal-\nto operate at unity power factor and, hence, exchanges only ancing the power exchanged between the ac side and the dc side,\nactive power with the gird. In order to achieve the decoupled the dynamic equation of the dc capacitor can be expressed\ncontrol of active and reactive power flowing between the GSC by\nand the grid, the stator-voltage-oriented synchronous reference\nframe, with its -axis aligning the stator voltage vector is\nWANG AND VO: POWER FLOW CONTROL AND STABILITY IMPROVEMENT OF CONNECTING AN OWF TO AN OMIB SYSTEM 361\n\n## designed for the SSSC in Section III to achieve to stability im-\n\nprovement. Whenever the ODC is used, the subtraction of\nand , instead of only , is multiplying by the current\nmagnitude to obtain required voltage magnitude .\nFrom the block diagram of the SSSC controller shown in\nFig. 8 and the above descriptions, the following equations can\nFig. 7. Equivalent circuits of an SSSC at the: (a) ac side; (b) dc side. be written by introducing an intermediate variable\n\n(5)\n(6)\n(7)\n\n## It should be noted that there is a similar control scheme known\n\nas a quadrature voltage control scheme. In this case, the required\ncompensating voltage magnitude is directly specified in-\nstead of multiplying the current magnitude by . For the\ndetails of the quadrature voltage control scheme, refer to .\nThe employed parameters for the models of this paper are listed\nin the Appendix.\n\n## III. DESIGN OF AN ODC FOR SSSC USING MODAL\n\nCONTROL THEORY\nFig. 8. Control block diagram of an SSSC as a power flow controller.\nThis section describes the design procedure and the results\nof the ODC of the proposed SSSC. The aim of the ODC for the\nThe SSSC may be operated under capacitive mode or inductive SSSC is to achieve stability improvement of the studied OMIB\nmode to increase or decrease the power flow through transmis- system under disturbance conditions. The nonlinear system\nsion line, respectively. In this paper, only the capacitive mode equations developed in Section II can be linearized around a\nof the SSSC is used. The control block diagram of the reactance selected nominal operating point to acquire a set of linearized\nscheme-based controller , – for an SSSC in capac- system equations in the matrix form of \nitive mode is shown in Fig. 8. This control scheme can be de-\nscribed as follows. (8)\nThe phase-locked loop (PLL) shown in Fig. 8 is used to deter-\n(9)\nmine the reference angle , which is phase-locked to phase of\nthe voltage at Bus #3.The - and -axis components of the line\ncurrent are calculated in a synchronous reference frame using where is the state vector, is the output vector, is the\nthe reference angle of the PLL. The magnitude of the line cur- external or the compensated input vector, is the disturbance\nrent and its relative angle with respect to the PLL angle input vector while , and are all constant matrices of\nare then calculated. The phase angle of the line current is cal- appropriate dimensions. The state vector can be divided into\nculated by adding the relative angle and the PLL angle . The several substate vectors such as - (electric system of\nrequired magnitude of the SSSC’s compensating voltage SG), - (electromechanical system of SG), -\nis determined by multiplying the current magnitude by the de- (excitation system of SG), - (PSS of SG), -\nsired compensating reactance . (turbine of SG), - (governor of SG), -\nThe phase angle of the required voltage is either (electric system of OWF), - (control system of OWF),\nin an inductive mode or in a capacitive mode. Since - (dc link of OWF), - (mechanical system\nonly the capacitive mode is used in this paper, the SSSC uses of OWF), and - (electromechanical system of OWF).\na fixed dc-to-ac gain across the VSI. The required dc When the proposed SSSC is added to the studied system, a\ncapacitor voltage is, hence, determined from required new substate vector - results. To design the ODC of\ncompensating voltage magnitude . The actual dc capacitor the SSSC, in (8) and in (9) can be properly ignored by\nvoltage is then compared to its required value and setting .\nthe error between them is passed through a PI controller which The second and the third columns of Table I list the calculated\nproduces an angle that is then added to the angle to ac- eigenvalues of the studied OMIB system plus the OWF system\nquire the final angle of the VSI. In Fig. 8, the desired com- without and with the proposed SSSC (compensating 50% of the\npensating reactance is directly specified to achieve the transmission line reactance) under the selected nominal oper-\npower flow control goal. Fig. 8 also shows an auxiliary signal ating conditions of p.u., p.u. (SG on\n(or damping signal) that comes from an ODC that will be 2220 MVA base), p.u., m/s (wind DFIG-\n362 IEEE TRANSACTIONS ON SUSTAINABLE ENERGY, VOL. 4, NO. 2, APRIL 2013\n\nTABLE I steady-state power flow control loop of the SSSC. Hence, the\nEIGENVALUES (rad/s) [DAMPING RATIO/FREQUENCY (Hz)] output signal in (9) is and the input signal in (8)\nOF THE STUDIED SYSTEM WITHOUT SSSC, WITH SSSC,\nAND WITH SSSC AND THE DESIGNED ODC\nand (9) is . The transfer function of the proposed\nPI ODC of the SSSC in domain is given by\n\n(10)\n\n## where is the time constant of the washout block while\n\nand are the proportional gain and the integral gain\nof the ODC, respectively. Taking the Laplace transformation\nof (8)–(9), an algebraic equation of the closed-loop system\ncontaining the PI ODC of the SSSC can be acquired . The\ndesign results of the PI ODC of the SSSC are given as below.\nPrespecified Eigenvalues\n\n## The system eigenvalues of the studied OMIB plus the DFIG-\n\nbased OWF system containing the SSSC and the designed PI\nODC are listed in the fourth column of Table I. When the de-\nsigned ODC of the SSSC is added to the studied system, a new\nsubstate vector - results are shown in Table I. It can\nbe clearly observed that have been exactly located on the\ndesired locations on the complex plane. It is also seen that the\ndamping ratio of the mechanical mode of the SG has been in-\ncreased from 0.042 to 0.142 but the frequency is kept at 1.37 Hz.\nFrom the eigenvalue results listed in the fourth column of Table I\nand the three parameters of the designed PI ODC, it can be\nconcluded that the design results are appropriate to the studied\nsystem. Steady-state analysis of the mechanical mode under dif-\nFig. 9. Control block diagram of the employed SSSC including the designed ferent operating conditions using the root-loci scheme as well as\nPI ODC. time-domain simulations using the developed nonlinear model\nsubject to a severe disturbance condition will be performed in\nSections IV and V, respectively.\nbased OWF), and p.u., respectively. Comparing the\neigenvalue results of these two columns listed in Table I, the IV. STEADY-STATE ROOT-LOCI ANALYSIS\ncomplex-conjugated eigenvalues refer to the mechanical\nThis section presents the root-loci analyzed results of the me-\nmode of the SG and it dominants the stability characteristics\nchanical mode of the OMIB plus the OWF system when the\nof the low-frequency oscillations of the OMIB system. When\noperating conditions are widely varied. The simulated output\nthe SSSC is included in the system, both damping ratio and active power of the SG is increased from 0.5 to 1.0 p.u.,\nfrequency have been increased. We can also observe that other the terminal voltage of the SG is increased from 0.95 to\nmodes are nearly fixed on the complex plane regardless of the 1.1 p.u., the output power factor of the SG (PF) is increased\naddition of the SSSC. Hence, the ODC of the SSSC needs to be from 0.5 lagging to 0.96 lagging, and the wind speed\nproperly designed to render adequate damping to the mechan- of the DFIG-based OWF is increased from 4 m/s (cut-in wind\nical mode of the SG. speed) to 24 m/s (cut-out wind speed). Fig. 10 plots the com-\nThe control block diagram of the equivalent reactance of the parative root-loci results for the mechanical mode of the studied\nSSSC including the PI ODC is shown in Fig. 9. It consists of OMIB system without SSSC, with SSSC, and with both SSSC\na washout block and a PI controller. The input signal of the and ODC under the selected operating conditions. The root-loci\nODC is the active-power deviation through Line 34-2, results shown in Fig. 10 are analyzed as follows.\nwhere the SSSC is inserted. The output signal of the ODC is a) Fig. 10(a) shows the comparative root-loci results of the\nthe damping signal (or auxiliary signal) that is added to mechanical mode under different values of . It is found\nthe reference reactance as the desired value using by the that the root loci of the mechanical mode move towards\nWANG AND VO: POWER FLOW CONTROL AND STABILITY IMPROVEMENT OF CONNECTING AN OWF TO AN OMIB SYSTEM 363\n\n## mechanical mode, again, moves away from the imaginary\n\naxis of the complex plane for all three cases when PF in-\ncreases. The mechanical mode may have the best damping\ncharacteristics when the proposed SSSC and the designed\nODC are both included in the system. The root loci of the\nmechanical mode are close to the imaginary axis of the\ncomplex plane when PF is low and the system is with and\nwithout the proposed SSSC.\nd) Fig. 10(d) shows the root-loci plots of the mechanical\nmode under different values of . It is discovered that\nmechanical mode is approximately fixed on the complex\nplane regardless the variations of . This is due to the\nfact that the capacity of the DFIG-based OWF is quite\nsmall and it is about 1/10 of the capacity of the SG. Again,\nthe mechanical mode may have the best damping charac-\nteristics when the proposed SSSC and the designed ODC\nare both included in the system.\n\nV. TIME-DOMAIN SIMULATIONS\nThis section employs the nonlinear system model devel-\noped in Section II to compare and demonstrate the damping\ncharacteristics contributed by the proposed SSSC joined with\nthe designed ODC under three cases (Case 1, Case 2, and\nCase 3). A three-phase short-circuit fault is suddenly applied\nto the infinite bus at s while the duration of the ap-\nplied fault lasts for six cycles (0.1 s) in Case 1 and 0.7 s in\nCase 2, respectively. Case 3 employs a sudden trip of the OWF\nand wind-speed change on the OWF to demonstrate that the\nlow-frequency oscillations of the SG can be excited by the\nDFIG-based OWF. The operating conditions of the studied\nsystem prior the severe disturbance are properly selected the\nsame as the ones of Table I.\n\nA. Case 1\nFig. 11 plots the comparative transient responses of the\nFig. 10. Comparative root-loci results for the mechanical mode under different studied system without the SSSC, with the SSSC, and with the\nvalues of: (a) , (b) , (c) PF, and (d) . SSSC joined with the designed ODC. It is clearly observed from\nthe comparative transient simulation results that all transient\nresponses of the studied system, i.e., Figs. 11(a)–(g) for the SG,\nthe imaginary axis of the complex plane for all three cases. Figs. 11(l)–(m) for the DFIG-based OWF, Figs. 11(h)–(j) for the\nWhen SSSC and ODC are both in service, the mechan- two transmission lines, etc., with the proposed SSSC joined with\nical mode can be maintained stable and nearly fixed on the designed PI ODC have the shortest time to quickly recover to\nthe complex plane. However, the mechanical mode has the original steady-state operating conditions in three responses.\nwidely varied and can be pushed towards the imaginary When the fault occurs, large amplitudes on all quantities shown\naxis when is increased. in Fig. 11 can be clearly found and the quantities of the system\nb) Fig. 10(b) illustrates the root-loci characteristics of the without the SSSC demonstrate the largest amplitudes in three\nmechanical mode under different values of . It is seen responses. It also shows that the proposed SSSC joined with the\nthat mechanical mode moves away from the imaginary designed ODC can simultaneously supply the proper amount\naxis of the complex plane for all three cases when in- of reactive power to the line of the studied system and offer\ncreases. However, the mechanical mode can have the best better damping characteristics to the mechanical mode of the\ndamping performance when the proposed SSSC and the SG in order to quickly damp out the low-frequency oscillations\ndesigned ODC are both in service. The root loci of the of the SG. Voltage responses of the studied system shown in\nmechanical mode locate close to the imaginary axis of the Fig. 11(a), (n), and (o) can also be effectively improved by the\ncomplex plane when is low and the system is with and proposed SSSC with the designed ODC. The voltage across the\nwithout the proposed SSSC. transmission-line side of the series coupling transformer shown\nc) Fig. 10(c) plots the root-loci outcomes of the mechanical in Fig. 11(o) rises as high as 1.6 p.u. when the SSSC is with\nmode under different values of PF. It is discovered that the designed ODC during the faulted interval. However, this\n364 IEEE TRANSACTIONS ON SUSTAINABLE ENERGY, VOL. 4, NO. 2, APRIL 2013\n\nFig. 11. Transient responses of the studied system subject to a three-phase short-circuit fault at the infinite bus: (a) , (b) , (c) , (d) , (e) , (f) ,\n(g) , (h) , (i) , (j) , (k) , (l) , (m) , (n) , and (o) .\n\ntransient high voltage decays faster than the one of the system the designed ODC. It is obviously observed from the compar-\nwith the SSSC but without the ODC. ative transient simulation results that all transient responses of\nthe studied system with the proposed SSSC joined with the de-\nB. Case 2 signed PI ODC are stable and quickly return back to their corre-\nFig. 12 illustrates the comparative transient responses of the sponding steady-state values in 5 s. On the other hand, all tran-\nstudied system with the SSSC and with the SSSC joined with sient responses of the studied system with the SSSC but without\nWANG AND VO: POWER FLOW CONTROL AND STABILITY IMPROVEMENT OF CONNECTING AN OWF TO AN OMIB SYSTEM 365\n\nFig. 12. Transient responses of the studied system subject to a three-phase short-circuit fault at the infinite bus under Case 2: (a) , (b) , (c) , (d) ,\n(e) , (f) , (g) , (h) , (i) , (j) , (k) , (l) , (m) , (n) , and (o) .\n\nthe designed PI ODC are unstable while all the responses di- ODC of the proposed SSSC can effectively stabilize the studied\nverge to unacceptable values in 1.1 s. It shows the designed system under an unstable scenario.\n366 IEEE TRANSACTIONS ON SUSTAINABLE ENERGY, VOL. 4, NO. 2, APRIL 2013\n\nFig. 13. Transient responses of the studied system when the DFIG-based OWF is suddenly tripped under Case 3: (a) , (b) , (c) , (d) , (e) , (f) ,\n(g) , (h) , (i) , (j) , (k) , (l) , (m) , (n) , and (o) .\n\nC. Case 3 the wind speed of the DFIG-based OWF changes. The varia-\ntions of the wind speed take into account the base wind speed,\nFig. 13 shows the transient responses of the studied system noise wind speed, gust wind speed, and ramp wind speed while\nwhen the DFIG-based OWF is suddenly tripped at s Fig. 14(o) shows the simulated wind speed . It is clearly\nwhile Fig. 14 shows the dynamic responses of the system when observed from the time-domain responses shown in Figs. 13\nWANG AND VO: POWER FLOW CONTROL AND STABILITY IMPROVEMENT OF CONNECTING AN OWF TO AN OMIB SYSTEM 367\n\nFig. 14. Dynamic responses of the studied system when the DFIG-based OWF is subject to a wind-speed change under Case 3: (a) , (b) , (c) , (d) ,\n(e) , (f) , (g) , (h) , (i) , (j) , (k) , (l) , (m) , (n) , and (o) .\n\nand 14(a)–(n) that the low-frequency oscillations of the SG can VI. CONCLUSION\nbe excited when the disturbances are at the DFIG-based OWF.\nFigs. 13 and 14 also show that the SSSC combined with the This paper has presented the stability-improvement and\ndesigned ODC can effectively suppress the low-frequency os- power-flow control results of an OMIB system with a\ncillation in these two studied cases. DFIG-based OWF using a static series compensator (SSSC).\n368 IEEE TRANSACTIONS ON SUSTAINABLE ENERGY, VOL. 4, NO. 2, APRIL 2013\n\nThe proposed SSSC has been properly connected in series with B. DFIG-Based OWF \none of the two parallel lines to supply adequate reactive power.\na) Wind turbine (rated 5 MW)\nA PI-type ODC has been designed for the proposed SSSC by\nusing a unified approach based on modal control theory to\nassign the mechanical mode of the studied OMIB system on the\ndesired locations of the complex plane. Root-loci plots under\nvarious operating conditions and time-domain simulations of\nthe studied OMIB system subject to a three-phase short-circuit\nfault at the infinite bus have been systematically performed b) Generator (per unit) (rated 5 MW, 0.69 kV)\nto demonstrate the effectiveness of the proposed SSSC joined\nwith the designed PI ODC on damping inherent low-frequency\noscillations of the studied OMIB system and improving system\nstability under different operating conditions. It can be con-\ncluded from the simulation results that the proposed SSSC c) Mass-spring-damper system\njoined with the designed ODC has the ability to improve the\nperformance of the studied OMIB plus the DFIG-based OWF\nsystem under different operating conditions. The designed\nODC of the proposed SSSC can also effectively stabilize the\nstudied system under an unstable scenario.\nC. SSSC (Per Unit) (Rated 134 MVA)\n\nAPPENDIX\nSYSTEM PARAMETERS\n\n## A. SG and Its Subsystems \n\na) Single SG (per unit) D. Network Impedances (Per Unit on 100 MVA Base)\n\nREFERENCES\n F. R. Schleif and J. H. White, “Damping of the northwest-southwest\ntieline oscillations—An analog study,” IEEE Trans. Power Apparat.\nSyst., vol. PAS-85, no. 12, pp. 1239–1247, Dec. 1966.\n Y. N. Yu, Electric Power Systems Dynamics. New York: Academic,\n1983.\n L. Wang, “A comparative study of damping scheme on damping gener-\nator oscillations,” IEEE Trans. Power Syst., vol. 8, no. 2, pp. 613–619,\nMay 1993.\n J. M. Gonzalez, C. A. Canizares, and J. M. Ramirez, “Stability mod-\neling and comparative study of series vectorial compensators,” IEEE\nTrans. Power Del., vol. 25, no. 2, pp. 1093–1103, Apr. 2010.\n N. G. Hingorani and L. Gyugyi, Understaning FACTS: Concepts and\nTechnology of Flexible AC Transmission Systems. Piscataway, NJ:\nb) Exciter and PSS (per unit) IEEE Press, 2000.\n S. Jiang, A. M. Gole, U. D. Annakkage, and D. A. Jacobson, “Damping\nperformance analysis of IPFC and UPFC controllers using validated\nsmall-signal models,” IEEE Trans. Power Del., vol. 26, no. 1, pp.\n446–454, Jan. 2011.\n L. Gyugyi, C. D. Schauder, and K. K. Sen, “Static synchronous series\ncompensator: A solid-state approach to series compensation of trans-\nmission lines,” IEEE Trans. Power Del., vol. 12, no. 1, pp. 406–417,\nJan. 1997.\n H. F. Wang, “Design of SSSC damping controller to improve power\nsystem oscillation stability,” in Proc. 1999 IEEE AFRICON, vol. 1, pp.\nc) Steam turbine and speed governor (per unit) 495–500.\n B. S. Rigby, N. S. Chonco, and R. G. Harley, “Analysis of a power\noscillation damping scheme using a voltage-source inverter,” IEEE\nTrans. Ind. Applicat., vol. 38, no. 4, pp. 1105–1113, Jul./Aug. 2002.\n K. K. Sen, “SSSC—Static synchronous series compensator: Theory,\nmodeling, and applications,” IEEE Trans. Power Del., vol. 13, no. 1,\npp. 241–245, Jan. 1998.\nWANG AND VO: POWER FLOW CONTROL AND STABILITY IMPROVEMENT OF CONNECTING AN OWF TO AN OMIB SYSTEM 369\n\n L. S. Kumar and A. Ghosh, “Modeling and control design of a static S. Panda, N. P. Padhy, and R. N. Patel, “Power-system stability im-\nsynchronous series compensator,” IEEE Trans. Power Del., vol. 14, no. provement by PSO optimized SSSC-based damping controller,” Elec-\n4, pp. 1448–1453, Oct. 1999. tric Power Compon. Syst., vol. 13, no. 5, pp. 468–490, 2008.\n M. S. Castro, H. M. Ayres, V. F. da-Costa, and L. C. P. da-Silva, “Im- A. C. Pradhan and P. W. Lehn, “Frequency-domain analysis of the\npacts of the SSSC control modes on small-signal and transient stability static synchronous series compensator,” IEEE Trans. Power Del., vol.\nof a power system,” Elect. Power Syst. Res., vol. 77, no. 1, pp. 1–9, 21, no. 1, pp. 440–449, Jan. 2006.\nJan. 2007. G. N. Pillai, A. Ghosh, and A. Joshi, “Torsional oscillation studies in\n G. Radman and R. S. Raje, “Dynamic model for power system with an SSSC compensated power system,” Elect. Power Syst. Res., vol. 55,\nmultiple FACTS controllers,” Elect. Power Syst. Res., vol. 78, no. 3, no. 1, pp. 57–64, Jul. 2000.\npp. 361–371, Mar. 2008. K. A. Padiyar, FACTS Controllers in Power Transmission and Distri-\n J. Guo, M. L. Crow, and J. Sarangapani, “An improved UPFC control bution. New Delhi: New Age, 2007.\nfor oscillation damping,” IEEE Trans. Power Syst., vol. 24, no. 1, pp. K. K. Sen and M. L. Sen, Introduction to FACTS Controllers: Theory,\n288–296, Feb. 2009. Modeling, and Applications. Hoboken, NJ: Wiley, 2007.\n A. Rajabi-Ghahnavieh, M. Fotuhi-Firuzabad, M. Shahidehpour, and R. L. Wang, S.-S. Chen, W.-J. Lee, and Z. Chen, “Dynamic stability en-\nFeuillet, “UPFC for enhancing power system reliability,” IEEE Trans. hancement and power flow control of a hybrid wind and marine-current\nPower Del., vol. 25, no. 4, pp. 2881–2890, Oct. 2010. farm using SMES,” IEEE Trans. Energy Convers., vol. 24, no. 3, pp.\n P. Kundur, Power System Stability and Control. New York: Mc- 626–639, Sep. 2009.\nGraw-Hill, 1994.\n CIGRE, Modeling New Forms of Generation and Storage TF.01.10,\nFifth draft, Jun. 2000.\nLi Wang (S’87–M’88–SM’05) received the Ph.D.\n P. C. Krause, Analysis of Electric Machinery. New York: McGraw-\ndegree from the Department of Electrical Engi-\nHill, 1987.\nneering, National Taiwan University, Taipei, Taiwan,\n D. J. Trudnowski, A. Gentile, J. M. Khan, and E. M. Petritz, “Fixed- in June 1988.\nspeed wind-generator and wind-park modeling for transient stability He has been an associated professor and a pro-\nstudies,” IEEE Trans. Power Syst., vol. 19, no. 4, pp. 1911–1917, Nov. fessor with the Department of Electrical Engineering,\n2004. National Cheng Kung University, Tainan, Taiwan\n S. M. Muyeen, M. H. Ali, R. Takahashi, T. Murata, J. Tamura, Y. in 1988 and 1995, respectively. He was a visiting\nTomaki, A. Sakahara, and E. Sasano, “Transient stability analysis scholar with the School of Electrical Engineering\nof wind generator system with the consideration of multi-mass shaft and Computer Science, Purdue University, West\nmodel,” in Proc. Int. Conf. Power Electronics and Drives Systems, Lafayette, IN, from February 2000 to July 2000, and\nJan. 16–18, 2006, vol. 1, pp. 511–516. the School of Electrical Engineering and Computer Science, Washington State\n P. Cartwright, L. Holdsworth, J. B. Ekanayake, and N. Jenkins, “Co- University, Pullman, WA, from August 2003 to January 2004. He was a re-\nordinated voltage control strategy for a doubly-fed induction generator search scholar of the Energy Systems Research Center (ESRC), the University\n(DFIG)-based wind farm,” in IEE Proc.-Gener. Transm. Distrib., Jul. of Texas at Arlington (UTA), Arlington, TX, from July 2008 to January 2009.\n2004, vol. 151, no. 4, pp. 495–502. At present, his research interests include power systems dynamics, power\n L. Yang, G. Y. Yang, Z. Xu, Z. Y. Dong, K. P. Wong, and X. Ma, system stability, ac machine analyses, and renewable energy.\n“Optimal controller design of a doubly-fed induction generator wind\nturbine system for small signal stability enhancement,” IET Generat.,\nTrans., Distribut., vol. 4, no. 5, pp. 579–597, May 2010.\n B. C. Pal and F. Mei, “Modelling adequacy of the doubly fed induc- Quang-Son Vo was born in Vietnam, on March\ntion generator for small-signal stability studies in power systems,” IET 08, 1980. He received the B.E. degree in electrical\nRenew. Power Generat., vol. 2, no. 3, pp. 181–190, Sep. 2008. engineering from the Department of Electrical\n L. Fan, R. Kavasseri, Z. L. Miao, and C. Zhu, “Modeling of DFIG- Engineering, Danang University of Technology,\nbased wind farms for SSR analysis,” IEEE Trans. Power Del., vol. 25, Vietnam, in July 2004, and the M.Sc. degree from\nno. 4, pp. 2073–2082, Oct. 2010. the Department of Electrical Engineering, National\n F. Wu, X.-P. Zhang, K. Godfrey, and P. Ju, “Small signal stability anal- Cheng Kung University, Taiwan, in July 2011.\nysis and optimal control of a wind turbine with doubly fed induction His research interests include power system sta-\ngenerator,” IET Generat., Trans., Distribut., vol. 1, no. 5, pp. 751–760, bility, FACTS, and wind power generation systems.\nSep. 2007." ]

[ null ]

[ "# Lydia Bieri Department of Mathematics University of Michigan, Ann Arbor and", null, "```Lydia Bieri\nDepartment of Mathematics\nUniversity of Michigan, Ann Arbor\nand\nCMSA Harvard University\nMotion of a Self-Gravitating Incompressible Fluid with Free Boundary.\nIn this talk, we consider the motion of the free boundary of an incompressible fluid body subject\nto its self-gravitational force. This can be described by a free boundary problem of the Euler-Poisson\nsystem. This situation di↵ers from the water wave case in that the constant gravity in water waves is\nreplaced by the nonlinear self-gravity. I shall present some recent results, in particular we give a lower\nbound on the lifespan of smooth solutions. We show that the Taylor sign condition always holds; we\nprove that for smooth data of size ✏, a unique solution exists and remains smooth for time greater\nthan or equal to O(1/✏2 ). This is achieved by constructing an appropriate quantity and a coordinate\nchange, so that the new quantity in the new coordinate system satisfies an equation without quadratic\nnonlinearity. This is joint work with Shuang Miao, Sohrab Shahshahani and Sijue Wu.\n```" ]

[ null, "https://s2.studylib.net/store/data/010491122_1-4939a4f270c0d00056105987a1aedcb2.png", null ]

[ "# Specify the randomization options for Create Gage R&R Study Worksheet\n\nStat > Quality Tools > Gage Study > Create Gage R&R Study Worksheet > Options\nSelect the randomization option that best describes how you want to collect your measurement data.\n• Do not randomize: Do not randomize the measurements so that the run order is the same as the standard order. The worksheet includes a column that lists the run order of all measurements sequentially (1 through the total number of runs).\n• Randomize all runs: Randomize the run order of all measurements. Each time you create another worksheet and randomize all runs again, you will have a different run order.\n• Randomize runs within operators: Randomize runs for each operator. Each operator measures all parts, in random order, for the first replicate. Then each operator measures all parts for the second replicate. For example, Operator 1 measures parts 1–10 in random order, then Operator 2 measures parts 1–10 in random order, for each replicate.\nRandomize operator sequence\nRandomly assign the operator order sequence for all the replicates. For example, suppose you have 3 operators and 2 replicates. The operator order will be random so that Operator 3 could measure all the parts in replicate 1, and all the parts in replicate 2, before Operator 1 measures the parts.\n\nFor more examples about randomizing your worksheet, go to Worksheet randomization for a gage R&R study.\n\nBase for random data generator\nEnter a positive integer to set the starting point of Minitab's random number generator. When you create a new data collection worksheet, if you want to use the same set of random orderings, set the base to the same value.\nStore standard run order in worksheet\nSpecify whether to store the standard order of runs in the worksheet. The standard order is the non-randomized order of the runs.\nBy using this site you agree to the use of cookies for analytics and personalized content.  Read our policy" ]

[ null ]

[ "# Thread: Cobb-Douglas Function: Inverse function and marginal cost\n\n1. ## Cobb-Douglas Function: Inverse function and marginal cost\n\nOk, so I wonder wether or not I have done this correctly:\nIt would be of great help to me.\n\nI have the Cobb-Douglas function $\\displaystyle x=An^e$\nWere x is produced quantum and n is the input labour.\n\nFirst question: Is the inverse function $\\displaystyle n=(x/A)^{1/e}$ ? and does that equal: $\\displaystyle n=(1/A^{1/e})(x^{1/e})$ ?\n\nSo the cost function then, were w is the price of labour: wn = $\\displaystyle (w/A^{1/e})(x^{1/e})$\n\nSecond Question: Is the derivative of the inverse function (if Ive done correctly on the first question):\n\n$\\displaystyle (w/eA^{1/e})(x^{(1/e)-1})$\n\n2. ## Re: Cobb-Douglas Function: Inverse function and marginal cost\n\nHey EconNor.\n\nAs a general rule, we find the inverse function (if it exists) by swapping the independent and dependent variable and re-solving for an expression of the new independent variable in terms of the dependent variable. In other words,\n\ny = f(x) [Original function] Swapping gives us\nx' = f(y').\nNow re-arrange to get\ny' = g(x') and g is our inverse function.\n\nIn your example y = x and x = n. Doing the above gives us:\n\nn = Ax^e\n(n/A)^(1/e) = x so our inverse function is\n\nx^(-1)(n) = (n/A)^(1/e) just as you predicted.\n\nFor the second we use the normal power rule which gives:\n\nd/dn[(n/A)^(1/e)]\n= (1/A)^(1/e) * (1/e) * n^(1/e - 1)\n\nWhere did you get your w from?\n\n3. ## Re: Cobb-Douglas Function: Inverse function and marginal cost\n\nOk, thank you.\n\nOh, the w is just for the cost function.... w = wage n=Hours of labour ... so the cost function is wn.\n\n,\n\n,\n\n,\n\n,\n\n,\n\n,\n\n# marginal cost cobb douglas\n\nClick on a term to search for related topics.\n\n#### Search Tags\n\ncobbdouglas, cost, function, inverse, marginal", null, "" ]

[ null, "http://cdn.mathhelpforum.com/images/misc/11x11progress.gif", null ]

[ "In the energy meter testing, the actual registration of energy (by the meter) is verified against known standard values at various loads and power factors. The energy meter testing helps in providing suitable adjustments in the meter so as to reduce errors. The actual registration is verified under the following test conditions.\n\n#### At rated voltage, 5% of rated current and unity power factor.At rated voltage, 125% of rated current and unity power factor.At rated voltage, rated current, and 0.5 lagging power factor.At rated voltage, 50% of rated current and unity power factor.At rated voltage, 0.5% of rated current and unity power factor. This test is called starting test. Since, at this small load also, the disc should start rotating, Of course, accuracy is not the criteria in this test.At 110% of rated voltage and open-circuited current coil. This test is called as creep test. The disc should not creep (or rotate) under this test conditions.\n\nIn order to test high capacity energy meters for the above conditions, tremendous loss of power will occur. Hence, to reduce wastage of power, phantom loading is used for testing the energy meter.\n\nAs shown in the figure above, the pressure coil (or the shunt winding) is energized with its rated voltage and the current coil (or the series winding) is energized by a low voltage supply. The impedance of the current coil circuit is quite small. So for the rated amount of current also, the power consumption will be small. Although the impedance of the pressure coil is high, the current through it is very small.\n\nHence, the power consumed in the pressure coil will also be small. Therefore, the overall power or energy dissipation during the testing period will be small. For this reason, phantom loading is considered to be the most economical one for testing purposes.\n\nConsider a 220V, 5A, dc energy meter is tested at the marked ratings. The resistance of the pressure coil circuit is 8800 ohm and that of a current coil is 0.1 ohm. Let us see the power consumed when testing the meter by direct loading and phantom loading." ]

[ null ]

[ "# 17 is what percent of 12?\n\n## (17 is 141.667 percent of 12)\n\n### 17 is 141.667 percent of 12. Explanation: What does 17 percent or 17% mean?\n\nPercent (%) is an abbreviation for the Latin “per centum”, which means per hundred or for every hundred. So, 17% means 17 out of every 100.\n\n### Methods to calculate \"17 is what percent of 12\" with step by step explanation:\n\n#### Method 1: Diagonal multiplication to calculate 17 is what percent of 12.\n\n1. Step 1: For 12, our answer will be 17\n2. Step 2: For 100, our answer will be x\n3. Step 3: 12*x = 17*100 (In Step 1 and 2 see colored text; Diagonal multiplications will always be equal)\n4. Step 4: x = 17*100/12 = 1700/12 = 141.667\n\n#### Method 2: Same side division to calculate 17 is what percent of 12\n\n1. Step 1: For 12, our answer will be 17\n2. Step 2: For 100, our answer will be x\n3. Step 3: 17/x = 12/100 (In Step 1 and 2, see colored text; Same side divisions will always be equal)\n4. Step 4: x/17 = 100/12\n5. Step 5: x = 17*100/12 = 1700/12 = 141.667\n\n### Percentage examples\n\nPercentages express a proportionate part of a total. When a total is not given then it is assumed to be 100. E.g. 17% (read as 17 percent) can also be expressed as 17/100 or 17:100.\n\nExample: If 17% (17 percent) of your savings are invested in stocks, then 17 out of every 100 dollars are invested in stocks. If your savings are \\$10,000, then a total of 17*100 (i.e. \\$1700) are invested in stocks.\n\n### Percentage sign (%)\n\nThe percent (per cent i.e. per hundred) sign % is the standard symbol to indicate a percentage, to signify a number or ratio as a fraction of 100. Related signs include the permille (per thousand) sign ‰ and the permyriad (per ten thousand) sign ‱ (also known as a basis point), which indicate that a number is divided by one thousand or ten thousand, respectively.\n\n### Scholarship programs to learn math\n\nHere are some of the top scholarships available to students who wish to learn math.\n\n### Examples to calculate \"What is the percent decrease from X to Y?\"\n\nWhatPercentCalculator.com is a participant in the Amazon Services LLC Associates Program, an affiliate advertising program designed to provide a means for sites to earn advertising fees by advertising and linking to Amazon.com." ]

[ null ]

[ "# How much is known about the \"inference rules\" of logical induction?\n\npost by Eigil Rischel (eigil-rischel) · 2020-08-08T10:45:09.029Z · LW · GW · 7 comments\n\nThis is a question post.\n\nContext: Logical Induction is a framework that makes sense of intuitively plausible statements like \"the probability that the th digit of is odd is about \".\n\nPeople often do this sort of informal reasoning about mathematical conjectures. Like \"The Collatz conjecture has been checked up to , and held for all those - updating on this, I increase my likelyhood that the conjecture is true in general\". Logical induction seems to provide, in principle, a set of rules that such updates should follow. How many of these rules are known?\n\nSome example rules that seem very plausible (here all my variables are implicitly natural numbers):\n\n• The observation that is true does not decrease the likelyhood of .\n• Updating on the observations \" for all \", the probability of goes to as\n\nDo these hold for logical inductors?\n\n## Answers\n\nanswer by Donald Hobson · 2020-08-09T14:46:13.552Z · LW(p) · GW(p)\nUpdating on the observations \"ϕ(n) for all 0≤n≤N\", the probability of ∀nϕ(n) goes to 1 as N→∞\n\nLogical induction doesn't have this property. No alternatives can either.\n\nTo make sense of this answer, I recommend reading\n\nand\n\nIn short, logical induction can't be sure if its operating in a nonstandard context or not. So suppose that is true for all standard numbers, but false for some nonstandard number. Logical Induction has no way to know whether it is operating in the standard or non-standard numbers, so assigns a probability strictly between 0 and 1 to it.\n\nSuppose you had an alternate algorithm that didn't do that. A Turing machine can be formally specified in PA, so we can talk about the output of the algorithm. The concept of limits can be discussed in PA using of foundational calculus. (The and actually need to be Natural numbers, but you can encode rational numbers in them with prime factors)\n\nSo for every formula in PA there exists another formula that says that your algorithm assigns probability 1 to in the limit. (And is computable from )\n\nLet be a PA formula with one free variable. takes in a number . If does not encode a PA formula with one free variable, then is false. If encodes , then . Now consider an integer encoding . And consider .\n\nThis is a straightforward modification of godels incompleteness theorem. If you have any procedure that can perfectly distinguish between true and false statements within the structure of PA, then you can make a \"this statement is false\" and get a contradiction.\n\nTechnical Note. I am also assuming that your proposed alternative to logical induction respects negation and implication in the limit. (Ie if and .)\n\nSome expressions in PA have multiple qualifiers Suppose we know that for every particular . Then by finite combinations of probabilities, and so . As , then it follows that any attempt at logical induction with this property must fail.\n\nEDIT:\n\nI have realized that I was confusing two separate concepts. You can't have any function from formulas to booleans that has the property . and the trivial preservation of logical operations. (definable within a formal first order theory with the same symbols)\n\nHowever, if you have a process that returns True, False or Maybe, and is never wrong, then you can extend it to another process like this. Take the first function. If is True or False, define otherwise, if and then =True. Otherwise Maybe.\n\nYou can't always combine infinite sequences of your own beliefs, but you can combine infinite sequences of beliefs from some weaker system, and each time you do that you move further up the arithmetic hierarchy.\n\nhttps://en.wikipedia.org/wiki/Arithmetical_hierarchy\n\nAs totally computable functions are in , the limit of a sequence of boolean functions is in . So as taking a forall over a function makes it a the highest you can get while still having\n\nUpdating on the observations \"ϕ(n) for all 0≤n≤N\", the probability of ∀nϕ(n) goes to 1 as N→∞\n\nIs . This means that you can have your asymtotic property compared to any function.\n\nLimits in the rationals add a to the front, puting them in . Meaning that your asymtotic property holds for all sets.\n\nWhat this means is that if you have a computable function which tends to 1 as if and only if then you can construct which tends to 1 if and only if .\n\nThe downside of this approach is that it assigns probability almost 1 to false statements.\n\nThe boolean function case is to take a function that searches for an explicit counterexample, and return a probability that tends to one if no counter example has been found yet.\n\ncomment by Steven Byrnes (steve2152) · 2020-08-10T12:10:47.741Z · LW(p) · GW(p)\n\nSorry if these are stupid questions...\n\nlogical induction can't be sure if its operating in a nonstandard context or not.\n\nThe question specified \"all my variables are implicitly natural numbers\". Why can't there be traders that specialize on questions specifically about standard numbers and ignore others? (I assume that the natural numbers are standard numbers, correct?) Also, what's the connection between nonstandard numbers and your Godel-like proof?\n\nIf you have any procedure that can perfectly distinguish between true and false statements within the structure of PA, then you can make a \"this statement is false\" and get a contradiction.\n\nI think it would be fun to find a concrete example... here's my attempt...\n\n=\"the logical inductor will assign probability <0.5 to  in the limit of infinitely many steps\"\n\n= \"the logical inductor will assign probability <0.5 to  after  inference steps\"\n\nso .\n\nThen maybe any individual  will be true, but the algorithm will never assign >0.5 probability to .\n\nDid I get that right? I'm very out of practice with my self-referential math so I have low confidence. :-P\n\nReplies from: donald-hobson\ncomment by Donald Hobson (donald-hobson) · 2020-08-10T15:35:01.078Z · LW(p) · GW(p)\n\nYour self referential maths is nearly right. Technically the limit is defined as as your could fail because is false, and logical induction only behaves well in the limit.\n\nThe paper says that the logical inductor will assign probability <0.5 to  after  inference steps\"\n\ntend to 0.5 as . But I havn't yet worked out the infinite case.\n\nThe question specified \"all my variables are implicitly natural numbers\". Why can't there be traders that specialize on questions specifically about standard numbers and ignore others? (I assume that the natural numbers are standard numbers, correct?)\n\nYou can't do that because non-standard numbers look really similar to standard numbers from the inside. There is no formula that is true on all standard numbers, and false on nonstandard numbers.\n\nSuppose you had a logical induction procedure that had the property that after updating on it believed .\n\nSo suppose you had with each depending only on . and as . (Produced by your alternative to logical induction, these represent the probability assigned to )\n\nSuppose you prove all that in PA. As PA has nonstandard models, the proof also holds in those. But we can pick a such that is true in the standard model, but false for some nonstandard x. There must exist nonstandard such that is infinitesimal.\n\nOtherwise the formula would distinguish standard k from nonstandard k. Assigning infinitesimal probability to something that actually happend is a form of bad behaviour that I think can be transported back to the standard domain.\n\nI think that the resulting behaviour is consistent, but results in poor behaviour.\n\nWill post more as I think of it.\n\ncomment by Eigil Rischel (eigil-rischel) · 2020-08-10T20:20:27.657Z · LW(p) · GW(p)\n\nThank you very much!\n\nI guess an argument of this type rules out a lot of reasonable-seeming inference rules - if a computable process can infer \"too much\" about universal statements from finite bits of evidence, you do this sort of Gödel argument and derive a contradiction. This makes a lot of sense, now that I think about it.\n\n## 7 comments\n\nComments sorted by top scores.\n\ncomment by Jalex Stark (jalex-stark-1) · 2020-08-09T00:46:54.722Z · LW(p) · GW(p)\n\nI think short timescale behavior of logical induction is model-dependent. I'm not sure whether your first conjecture is true, and I'd guess that it's false in some models.\n\nI find myself a little confused. Isn't it the case that the probability of statement converges to 1 if and only if it is provable?\n\ncomment by River (frank-bellamy) · 2020-08-08T19:43:46.534Z · LW(p) · GW(p)\n\nIs there a reason to think this would be different than any other kind of induction or Bayesian reasoning? We use probabilities to describe things for which there is a true answer that we happen not to know all the time. Probability is often (arguably always) subjective in that way. For example, what is the probability that you, Eigil Rischel, have any siblings? The answer, in an objective sense, is either 0 or 1. The answer, from your subjective perspective, is either very close to 0 or very close to 1. But from my perspective not knowing anything about you, I'm going to put it at 0.7. If I wanted a better estimate, I could actually look up what fraction of people have siblings and use that. If I wanted an even better estimate, I could ask you. But right now, from my perspective, the probability of you having siblings is 0.7. This seems straight forward for physical truths, I don't see any real difference for mathematical truths. You should be able to use all the standard rules of probability theory, Bayes theorem, etc.\n\nI'm unsure that your second bullet point follows. For that limit to work, I should be able to pick a (finite) N such that if psi(n) for all 0<=n<=N, then the probability of \"for all n psi(n)\" is greater than or equal to .9. I don't know how to find such an N. How do I know that the limit isn't 0.8? Intuitively I feel like just checking more and more values of n should not get us arbitrarily close to certainty, but I don't know how to justify that intuition rigorously. Infinities are weird. Possibly infinities give us different rules for certain mathematical truths, I don't know. I would be curious to hear other people's thoughts.\n\nReplies from: jalex-stark-1\ncomment by Jalex Stark (jalex-stark-1) · 2020-08-09T00:42:22.922Z · LW(p) · GW(p)\n\nEigel is asking a specific (purely mathematical!) question about \"logical induction\", which is defined in the paper they linked to. Your comment seems to miss the question." ]

[ null ]

[ "# Object Controller Falloff\n\n## Description\n\nThis node creates a vector based falloff that associates to every object a float that is equal to inverse the distance from it to some controller object, that distance can be 3D or 1D.\n\n## Options\n\n### Sphere\n\nThis option associates to every object a float that is equal to inverse the distance from it to some controller object. This float is always in `[0,1]` range, So some distances will be clamped to `1` or `0`. We conclude that objects that are closer to the controller will have a large float that doesn’t exceed `1` and as objects gets away, their floats starts to fade till it becomes zero at some point. This float is added to the scale of the controller object, so scaling the controller object will result in increase in the floats of every object.\n\n#### Illustration\n\nIn this illustration, I set the z-position of the points of a line to their falloff floats which formed some kind of triangle. As we said, the float is equal to inverse the distance from the point to the position of the input object which I placed at `(0,0,0)` in this illustration. Let the distance be `D`, then inverse of the distance is `1-D`. So point `(0,0,0)` will have a `D` of `0` (because distance between `(0,0,0)` and `(0,0,0)` is zero) and a `1-D=1-0=1`, that’s why the point in the middle have a z-location of `1`. Point `(1,0,0)` on the other hand have a `D` of `1` and a `1-D=1-1=0` , that’s why the point at `(1,0,0)` has a z-location of zero. Points further away will have a negative inverse distances and thus negative z-locations. But as we said, values are clamped to `[0,1]` range and so negative floats will be zeroes and floats larger than one will be equal ones (We currently don’t have values larger than one).\n\nWhat I am going to do is add some value to the floats which result in inverse distances larger than one which will then be clamped to one, since the inverse distance is the z-location of the points, adding a value to the float will result in moving the triangle in the z-direction. The illustration shows what happens when this value is added when clamping is present.\n\nFurthermore, multiplying the floats by some value will change the rate of changing of the floats and thus have a wider based triangle, which is shown in the illustration as scaling the triangle which is what multiplication graphically denote.\n\nIn the node inputs, input Offset is the value that gets added while input Width is the value that gets multiplied.\n\nShaded area is the actual points position after clamping, outline is the values before clamping. Notice how outline exceed one and deceed zero:\n\n### Directional\n\nThis option associates to every object a float that is equal to inverse the distance from it to some controller object along a single axis. The chosen axis will be the local axis of the controller object, so rotating the object changes the direction. This float is always in `[0,1]` range, So some distances will be clamped to `1` or `0`. We conclude that objects that are closer to the controller along some axis will have a large float that doesn’t exceed `1` and as object gets away, their floats starts to fade till it becomes zero at some point. This float is multiplied by the scale of the controller object, so scaling the controller object will result in increase in the floats of every object.\n\nUse the same reasoning as the sphere option to understand this better.\n\nThis option creates a Radial Falloff where the plane is defined by the position and orientation of the input controller object. Any of the axis can be chosen as the normal of the plane. See the Radial Falloff node for more information.\n\n## Inputs\n\n• Controller - An object to use as the controller. You probably want to use empties because actual objects won’t make a difference, all the node needs is their location, rotation and scale.\n• Offset - This float will be added to the floats of all object resulting in an offset just as if you scaled the controller. (Only in Sphere option)\n• Falloff Width - This float defines the distance between the ones and zeros, so a higher value will result in smoother result with lower slope. (Only in Sphere option)\n• Interpolation - Floats will be evaluated at this interpolation.\n• Invert - If true, the floats will be inverted, so zeroes will be ones and ones will be zeroes.\n\n## Outputs\n\n• Falloff - The actual falloff object." ]

[ null ]

[ "# Categories of Pointwise Convergence Topology: Theory(ies) of Bundles.\n\nLet H be a fixed, separable Hilbert space of dimension ≥ 1. Lets denote the associated projective space of H by P = P(H). It is compact iff H is finite-dimensional. Let PU = PU(H) = U(H)/U(1) be the projective unitary group of H equipped with the compact-open topology. A projective bundle over X is a locally trivial bundle of projective spaces, i.e., a fibre bundle P → X with fibre P(H) and structure group PU(H). An application of the Banach-Steinhaus theorem shows that we may identify projective bundles with principal PU(H)-bundles and the pointwise convergence topology on PU(H).\n\nIf G is a topological group, let GX denote the sheaf of germs of continuous functions G → X, i.e., the sheaf associated to the constant presheaf given by U → F(U) = G. Given a projective bundle P → X and a sufficiently fine good open cover {Ui}i∈I of X, the transition functions between trivializations P|Ui can be lifted to bundle isomorphisms gij on double intersections Uij = Ui ∩ Uj which are projectively coherent, i.e., over each of the triple intersections Uijk = Ui ∩ Uj ∩ Uk the composition gki gjk gij is given as multiplication by a U(1)-valued function fijk : Uijk → U(1). The collection {(Uij, fijk)} defines a U(1)-valued two-cocycle called a B-field on X,which represents a class BP in the sheaf cohomology group H2(X, U(1)X). On the other hand, the sheaf cohomology H1(X, PU(H)X) consists of isomorphism classes of principal PU(H)-bundles, and we can consider the isomorphism class [P] ∈ H1(X,PU(H)X).\n\nThere is an isomorphism\n\nH1(X, PU(H)X) → H2(X, U(1)X) provided by the\n\nboundary map [P] ↦ BP. There is also an isomorphism\n\nH2(X, U(1)X) → H3(X, ZX) ≅ H3(X, Z)\n\nThe image δ(P) ∈ H3(X, Z) of BP is called the Dixmier-Douady invariant of P. When δ(P) = [H] is represented in H3(X, R) by a closed three-form H on X, called the H-flux of the given B-field BP, we will write P = PH. One has δ(P) = 0 iff the projective bundle P comes from a vector bundle E → X, i.e., P = P(E). By Serre’s theorem every torsion element of H3(X,Z) arises from a finite-dimensional bundle P. Explicitly, consider the commutative diagram of exact sequences of groups given by", null, "where we identify the cyclic group Zn with the group of n-th roots of unity. Let P be a projective bundle with structure group PU(n), i.e., with fibres P(Cn). Then the commutative diagram of long exact sequences of sheaf cohomology groups associated to the above commutative diagram of groups implies that the element BP ∈ H2(X, U(1)X) comes from H2(X, (Zn)X), and therefore its order divides n.\n\nOne also has δ(P1 ⊗ P2) = δ(P1) + δ(P2) and δ(P) = −δ(P). This follows from the commutative diagram", null, "and the fact that P ⊗ P = P(E) where E is the vector bundle of Hilbert-Schmidt endomorphisms of P . Putting everything together, it follows that the cohomology group H3(X, Z) is isomorphic to the group of stable equivalence classes of principal PU(H)-bundles P → X with the operation of tensor product.\n\nWe are now ready to define the twisted K-theory of the manifold X equipped with a projective bundle P → X, such that Px = P(H) ∀ x ∈ X. We will first give a definition in terms of Fredholm operators, and then provide some equivalent, but more geometric definitions. Let H be a Z2-graded Hilbert space. We define Fred0(H) to be the space of self-adjoint degree 1 Fredholm operators T on H such that T2 − 1 ∈ K(H), together with the subspace topology induced by the embedding Fred0(H) ֒→ B(H) × K(H) given by T → (T, T2 − 1) where the algebra of bounded linear operators B(H) is given the compact-open topology and the Banach algebra of compact operators K = K(H) is given the norm topology.\n\nLet P = PH → X be a projective Hilbert bundle. Then we can construct an associated bundle Fred0(P) whose fibres are Fred0(H). We define the twisted K-theory group of the pair (X, P) to be the group of homotopy classes of maps\n\nK0(X, H) = [X, Fred0(PH)]\n\nThe group K0(X, H) depends functorially on the pair (X, PH), and an isomorphism of projective bundles ρ : P → P′ induces a group isomorphism ρ∗ : K0(X, H) → K0(X, H′). Addition in K0(X, H) is defined by fibre-wise direct sum, so that the sum of two elements lies in K0(X, H2) with [H2] = δ(P ⊗ P(C2)) = δ(P) = [H]. Under the isomorphism H ⊗ C2 ≅ H, there is a projective bundle isomorphism P → P ⊗ P(C2) for any projective bundle P and so K0(X, H2) is canonically isomorphic to K0(X, H). When [H] is a non-torsion element of H3(X, Z), so that P = PH is an infinite-dimensional bundle of projective spaces, then the index map K0(X, H) → Z is zero, i.e., any section of Fred0(P) takes values in the index zero component of Fred0(H).\n\nLet us now describe some other models for twisted K-theory which will be useful in our physical applications later on. A definition in algebraic K-theory may given as follows. A bundle of projective spaces P yields a bundle End(P) of algebras. However, if H is an infinite-dimensional Hilbert space, then one has natural isomorphisms H ≅ H ⊕ H and\n\nEnd(H) ≅ Hom(H ⊕ H, H) ≅ End(H) ⊕ End(H)\n\nas left End(H)-modules, and so the algebraic K-theory of the algebra End(H) is trivial. Instead, we will work with the Banach algebra K(H) of compact operators on H with the norm topology. Given that the unitary group U(H) with the compact-open topology acts continuously on K(H) by conjugation, to a given projective bundle PH we can associate a bundle of compact operators EH → X given by\n\nEH = PH ×PU K\n\nwith δ(EH) = [H]. The Banach algebra AH := C0(X, EH) of continuous sections of EH vanishing at infinity is the continuous trace C∗-algebra CT(X, H). Then the twisted K-theory group K(X, H) of X is canonically isomorphic to the algebraic K-theory group K(AH).\n\nWe will also need a smooth version of this definition. Let AH be the smooth subalgebra of AH given by the algebra CT(X, H) = C(X, L1PH),\n\nwhere L1PH = PH ×PUL1. Then the inclusion CT(X, H) → CT(X, H) induces an isomorphism KCT(X, H) → KCT(X, H) of algebraic K-theory groups. Upon choosing a bundle gerbe connection, one has an isomorphism KCT(X, H) ≅ K(X, H) with the twisted K-theory defined in terms of projective Hilbert bundles P = PH over X.\n\nFinally, we propose a general definition based on K-theory with coefficients in a sheaf of rings. It parallels the bundle gerbe approach to twisted K-theory. Let B be a Banach algebra over C. Let E(B, X) be the category of continuous B-bundles over X, and let C(X, B) be the sheaf of continuous maps X → B. The ring structure in B equips C(X, B) with the structure of a sheaf of rings over X. We can therefore consider left (or right) C(X, B)-modules, and in particular the category LF C(X, B) of locally free C(X, B)-modules. Using the functor in the usual way, for X an equivalence of additive categories\n\nE(B, X) ≅ LF (C(X, B))\n\nSince these are both additive categories, we can apply the Grothendieck functor to each of them and obtain the abelian groups K(LF(C(X, B))) and K(E(B, X)). The equivalence of categories ensures that there is a natural isomorphism of groups\n\nK(LF (C(X, B))) ≅ K(E(B, X))\n\nThis motivates the following general definition. If A is a sheaf of rings over X, then we define the K-theory of X with coefficients in A to be the abelian group\n\nK(X, A) := K LF(A)\n\nFor example, consider the case B = C. Then C(X, C) is just the sheaf of continuous functions X → C, while E(C, X) is the category of complex vector bundles over X. Using the isomorphism of K-theory groups we then have\n\nK(X, C(X,C)) := K(LF (C(X, C))) ≅ K (E(C, X)) = K0(X)\n\nThe definition of twisted K-theory uses another special instance of this general construction. For this, we define an Azumaya algebra over X of rank m to be a locally trivial algebra bundle over X with fibre isomorphic to the algebra of m × m complex matrices over C, Mm(C). An example is the algebra End(E) of endomorphisms of a complex vector bundle E → X. We can define an equivalence relation on the set A(X) of Azumaya algebras over X in the following way. Two Azumaya algebras A, A′ are called equivalent if there are vector bundles E, E′ over X such that the algebras A ⊗ End(E), A′ ⊗ End(E′) are isomorphic. Then every Azumaya algebra of the form End(E) is equivalent to the algebra of functions C(X) on X. The set of all equivalence classes is a group under the tensor product of algebras, called the Brauer group of X and denoted Br(X). By Serre’s theorem there is an isomorphism\n\nδ : Br(X) → tor(H3(X, Z))\n\nwhere tor(H3(X, Z)) is the torsion subgroup of H3(X, Z).\n\nIf A is an Azumaya algebra bundle, then the space of continuous sections C(X, A) of X is a ring and we can consider the algebraic K-theory group K(A) := K0(C(X,A)) of equivalence classes of projective C(X, A)-modules, which depends only on the equivalence class of A in the Brauer group. Under the equivalence, we can represent the Brauer group Br(X) as the set of isomorphism classes of sheaves of Azumaya algebras. Let A be a sheaf of Azumaya algebras, and LF(A) the category of locally free A-modules. Then as above there is an isomorphism\n\nK(X, C(X, A)) ≅ K Proj (C(X, A))\n\nwhere Proj (C(X, A)) is the category of finitely-generated projective C(X, A)-modules. The group on the right-hand side is the group K(A). For given [H] ∈ tor(H3(X, Z)) and A ∈ Br(X) such that δ(A) = [H], this group can be identified as the twisted K-theory group K0(X, H) of X with twisting A. This definition is equivalent to the description in terms of bundle gerbe modules, and from this construction it follows that K0(X, H) is a subgroup of the ordinary K-theory of X. If δ(A) = 0, then A is equivalent to C(X) and we have K(A) := K0(C(X)) = K0(X). The projective C(X, A)-modules over a rank m Azumaya algebra A are vector bundles E → X with fibre Cnm ≅ (Cm)⊕n, which is naturally an Mm(C)-module." ]

[ null, "https://altexploit.files.wordpress.com/2018/03/untitled2.png", null, "https://altexploit.files.wordpress.com/2018/03/untitled3.png", null ]

[ "Student[MultivariateCalculus] - Maple Programming Help\n\nHome : Support : Online Help : Education : Student Packages : Multivariate Calculus : Lines and Planes : Student/MultivariateCalculus/Angle\n\nStudent[MultivariateCalculus]\n\n Angle\n Determine the angle between lines, vectors, and planes.\n\n Calling Sequence Angle(x, y)\n\nParameters\n\n x - a vector, a line, or a plane y - a vector, a line, or a plane\n\nDescription\n\n • The Angle command determines the angle between two vectors, a vector and a line, a vector and a plane, two lines, a line and a plane, or two planes.\n\nNotes\n\n • The angle between two intersecting lines can be measured at the intersection point; the angle returned is in the interval $\\left[0,\\frac{\\mathrm{\\pi }}{2}\\right]$. When two lines do not intersect, we define the angle determined by them as the angle between two lines through the origin parallel to the given lines.\n • The angle between two planes is equal to the angle between their normals.\n • The angle between a line and a plane is equal to the complement of the angle between the line and the normal of the plane.\n • An angle involving one vector, v, is the same as if instead of the vector, you had supplied a line having v as its direction. An angle between two vectors is slightly different, in that it can attain all values in $\\left[0,\\mathrm{\\pi }\\right]$.\n\nExamples\n\n > $\\mathrm{with}\\left({\\mathrm{Student}}_{\\mathrm{MultivariateCalculus}}\\right):$\n > $\\mathrm{v1}≔⟨1,2,3⟩:$\n > $\\mathrm{v2}≔⟨0,0,1⟩:$\n > $\\mathrm{v3}≔⟨a,b,c⟩:$\n > $\\mathrm{l1}≔\\mathrm{Line}\\left(\\left[0,0,0\\right],⟨1,2,4⟩\\right):$\n > $\\mathrm{l2}≔\\mathrm{Line}\\left(\\left[1,1,2\\right],⟨2,3,0⟩\\right):$\n > $\\mathrm{p1}≔\\mathrm{Plane}\\left(\\left[1,2,0\\right],⟨-1,1,0⟩\\right):$\n > $\\mathrm{p2}≔\\mathrm{Plane}\\left(\\left[1,1,2\\right],⟨1,2,1⟩\\right):$\n\nAngle between two vectors\n\n > $\\mathrm{Angle}\\left(\\mathrm{v1},\\mathrm{v2}\\right)$\n ${\\mathrm{arccos}}{}\\left(\\frac{{3}{}\\sqrt{{14}}}{{14}}\\right)$ (1)\n\nAngle between a vector and a line\n\n > $\\mathrm{Angle}\\left(\\mathrm{v3},\\mathrm{l1}\\right)$\n ${\\mathrm{min}}{}\\left({\\mathrm{\\pi }}{-}{\\mathrm{arccos}}{}\\left(\\frac{\\left({a}{+}{2}{}{b}{+}{4}{}{c}\\right){}\\sqrt{{21}}}{{21}{}\\sqrt{{{a}}^{{2}}{+}{{b}}^{{2}}{+}{{c}}^{{2}}}}\\right){,}{\\mathrm{arccos}}{}\\left(\\frac{\\left({a}{+}{2}{}{b}{+}{4}{}{c}\\right){}\\sqrt{{21}}}{{21}{}\\sqrt{{{a}}^{{2}}{+}{{b}}^{{2}}{+}{{c}}^{{2}}}}\\right)\\right)$ (2)\n\nAngle between a vector and a plane\n\n > $\\mathrm{Angle}\\left(\\mathrm{v2},\\mathrm{p1}\\right)$\n ${0}$ (3)\n\nAngle between two lines\n\n > $\\mathrm{Angle}\\left(\\mathrm{l1},\\mathrm{l2}\\right)$\n ${\\mathrm{arccos}}{}\\left(\\frac{{8}{}\\sqrt{{21}}{}\\sqrt{{13}}}{{273}}\\right)$ (4)\n\nAngle between a line and a plane\n\n > $\\mathrm{Angle}\\left(\\mathrm{l2},\\mathrm{p1}\\right)$\n $\\frac{{\\mathrm{\\pi }}}{{2}}{-}{\\mathrm{arccos}}{}\\left(\\frac{\\sqrt{{13}}{}\\sqrt{{2}}}{{26}}\\right)$ (5)\n\nAngle between two planes\n\n > $\\mathrm{Angle}\\left(\\mathrm{p1},\\mathrm{p2}\\right)$\n ${\\mathrm{arccos}}{}\\left(\\frac{\\sqrt{{2}}{}\\sqrt{{6}}}{{12}}\\right)$ (6)\n\nCompatibility\n\n • The Student[MultivariateCalculus][Angle] command was introduced in Maple 18." ]

[ null ]

[ "# Writing Linear Equations Worksheet\n\nIf you are looking for Writing Linear Equations Worksheet you’ve come to the right place. We have 31 worksheets about Writing Linear Equations Worksheet including images, pictures, photos, wallpapers, and more. In these page, we also have variety of worksheets available. Such as png, jpg, animated gifs, pic art, logo, black and white, transparent, etc.", null, "270 x 350 · jpeg writing linear equations worksheet laurence shauby tpt from www.teacherspayteachers.com", null, "500 x 647 · jpeg writing linear equation slope point from www.math-drills.com", null, "791 x 1024 · png writing linear equations worksheet from ivuyteq.blogspot.com", null, "1680 x 2048 · jpeg writing linear equations word problems worksheet db excelcom from db-excel.com", null, "1275 x 1650 · png worksheet writing linear equations worksheet grass fedjp worksheet from www.grassfedjp.com", null, "495 x 640 · jpeg writing linear equations worksheet answer combining terms from chripchirp.blogspot.com", null, "1600 x 1264 · jpeg writing linear equations worksheet answer from imsyaf.com", null, "500 x 647 · jpeg writing linear equation points from www.math-drills.com", null, "1285 x 1661 · jpeg writing linear equations worksheet answers worksheet resume examples from www.thesecularparent.com", null, "464 x 600 · jpeg writing linear equations worksheet answer worksheet project list from isme-special.blogspot.com", null, "405 x 574 · png writing equations parallel perpendicular lines worksheetwritings from byveera.blogspot.com", null, "270 x 350 · jpeg writing linear equations worksheet answer worksheet from novenalunasolitaria.blogspot.com", null, "1224 x 1584 · jpeg solving linear equations practice worksheet from briefencounters.ca", null, "1000 x 1291 · jpeg writing linear equations practice worksheet from www.liveworksheets.com", null, "500 x 647 · jpeg writing linear equation slope point algebra worksheet from www.math-drills.com", null, "768 x 1380 · png writing linear equations interactive worksheet allison schrank from app.wizer.me", null, "464 x 600 · jpeg writing linear equations worksheet grade lesson planet from www.lessonplanet.com", null, "900 x 1165 · jpeg solving simple linear equations unknown values from www.pinterest.com", null, "495 x 640 · jpeg writing linear equations worksheet worksheet source from dontyou79534.blogspot.com", null, "612 x 792 · png algebra worksheets linear equations worksheets from www.math-aids.com", null, "814 x 1026 · png algebra worksheet writing linear equations harbour league from theharbourleague.org", null, "405 x 574 · png standard form linear equation worksheet support worksheet from martindxmguide.blogspot.com", null, "828 x 970 · jpeg writing linear equations worksheet answers db excelcom from db-excel.com", null, "263 x 350 · jpeg writing linear equations carousel activity love math from www.teacherspayteachers.com", null, "1224 x 1584 · jpeg images writing linear equations worksheet linear equations from www.worksheeto.com", null, "1275 x 1651 · png writing linear equations worksheet answers support worksheet from martindxmguide.blogspot.com", null, "900 x 1165 · jpeg grade linear equations worksheet answers kidsworksheetfun from kidsworksheetfun.com", null, "1240 x 1754 · png images linear equation practice worksheets linear from www.worksheeto.com", null, "720 x 960 · jpeg algebra linear functions worksheet answers kidsworksheetfun from kidsworksheetfun.com", null, "386 x 500 · png writing linear equations slope intercept form worksheet from www.tes.com", null, "495 x 640 · jpeg writing linear equations worksheet answer key algebra kuta software from vegandivasnyc.com\n\nDon’t forget to bookmark Writing Linear Equations Worksheet using Ctrl + D (PC) or Command + D (macos). If you are using mobile phone, you could also use menu drawer from browser. Whether it’s Windows, Mac, iOs or Android, you will be able to download the worksheets using download button." ]

[ null, "http://tse4.mm.bing.net/th", null, "http://tse4.mm.bing.net/th", null, "http://tse4.mm.bing.net/th", null, "http://tse4.mm.bing.net/th", null, "http://tse3.mm.bing.net/th", null, "http://tse1.mm.bing.net/th", null, "http://tse4.mm.bing.net/th", null, "http://tse3.mm.bing.net/th", null, "http://tse1.mm.bing.net/th", null, "http://tse4.mm.bing.net/th", null, "http://tse1.mm.bing.net/th", null, "http://tse1.mm.bing.net/th", null, "http://tse4.mm.bing.net/th", null, "http://tse3.mm.bing.net/th", null, "http://tse1.mm.bing.net/th", null, "http://tse2.mm.bing.net/th", null, "http://tse1.mm.bing.net/th", null, "http://tse2.mm.bing.net/th", null, "http://tse2.mm.bing.net/th", null, "http://tse3.mm.bing.net/th", null, "http://tse3.mm.bing.net/th", null, "http://tse2.mm.bing.net/th", null, "http://tse4.mm.bing.net/th", null, "http://tse1.mm.bing.net/th", null, "http://tse4.mm.bing.net/th", null, "http://tse3.mm.bing.net/th", null, "http://tse2.mm.bing.net/th", null, "http://tse1.mm.bing.net/th", null, "http://tse4.mm.bing.net/th", null, "http://tse2.mm.bing.net/th", null, "http://tse1.mm.bing.net/th", null ]

[ "# Update add_edge_list vertex property map\n\nHi,\nHowever, I have to do the operation more than once and I was wondering if\nthere was a way of updating property maps. For example:\ng = Graph()\nedges = [(0, 1), (4, 6), (1, 2)]\ng.vp[\"vertex_map\"] = vertex_map\nprint([(g.vertex_index[v], g.vp[\"vertex_map\"][v]) for v in g.vertices()])\n# [(0, 0), (1, 1), (2, 4), (3, 6), (4, 2)]\nedges = [(1, 6), (7, 8)]" ]

[ null ]

[ "", null, "", null, "# Modeling Thermally Induced Focal Shift in High-Powered Laser Systems\n\nNovember 18, 2014\n\nAlmost all media absorb electromagnetic radiation to some extent. In high-powered laser focusing systems, a medium such as a glass lens may absorb enough energy from the laser to heat up significantly, resulting in thermal deformation and changing the material’s refractive index. These perturbations, in turn, can change the way the laser propagates. With the Ray Optics Module, it is possible to create a fully self-consistent model of laser propagation that includes thermal and structural effects.\n\n### Fundamentals of Thermal Lensing\n\nTo understand how ray trajectories are affected by self-induced temperature changes, consider a collimated beam that strikes a pane of glass at normal incidence. Assume that an anti-reflective coating has been applied to the glass surface so that the rays are not reflected. A typical pane of glass absorbs a very small, but nonzero, fraction of the power transmitted by the beam. If the power is sufficiently low, the temperature change within the glass will be negligible, and the outgoing rays will be parallel to the incoming rays.", null, "However, if a large amount of power is transmitted by the beam, the power absorbed by the pane of glass may substantially alter the temperature of the glass. The glass expands slightly, changing the angle of incidence of the rays and causing the transmitted rays to be deflected from their initially parallel trajectories. In addition, many materials have temperature-dependent refractive indices, and the temperature-induced change in the refractive index can also perturb the ray trajectories. Because the structural deformation and the change in refractive index tend to focus the outgoing rays, this phenomenon is known as thermal lensing.", null, "Next, we take a more in-depth look at an application in which thermal and structural effects can significantly perturb ray trajectories.\n\n### Modeling a Laser Focusing System\n\nConsider a basic laser focusing system that consists of two plano-convex lenses. The first lens collimates the output of an optical fiber while the second lens focuses the collimated beam toward a small target.", null, "If the laser beam delivers a small amount of power, then it is straightforward to model the propagation of the beam toward the target by using the Geometrical Optics interface and ignoring the temperature change in the lenses. The following image shows the trajectories of the rays in the lens system.", null, "However, even a high-quality glass lens absorbs a small fraction of the electromagnetic radiation that passes through it. If the optical fiber delivers a very large amount of power, then a thermally induced focal shift may occur; in other words, the changes in refractive index and lens shape can move the focus of the beam by a significant amount. If it is necessary to focus the laser accurately, then the possibility of thermally induced focal shift must be taken into account when designing the lens system.\n\nIn this example, we will observe how the temperature change in the lenses causes the beam to be focused at a location several millimeters away from the target.\n\n### Modeling Ray Propagation in Absorbing Media\n\nTo model ray propagation in the thermally deformed lens system, we use the following physics interfaces:\n\n• Geometrical Optics — To compute the ray trajectories.\n• Heat Transfer in Solids — To compute the temperature in the lenses.\n• Solid Mechanics — To model the thermal expansion of the lenses.\n• Moving Mesh — To deform the finite element mesh in domains adjacent to the lenses.\n\nThe physics interfaces and nodes used in this model are shown in the following screenshot.", null, "In addition to the Ray Optics Module, either the Structural Mechanics Module or the MEMS Module is needed to model the thermal expansion of the lenses.\n\n#### Ray Trajectory Computation\n\nUnder the hood, the Ray Optics Module computes the ray trajectories by solving a set of coupled first-order ordinary differential equations,\n\n(1)\n\n\\begin{aligned}\n\\frac{d\\mathbf{q}}{dt} &= \\frac{\\partial \\omega}{\\partial \\mathbf{k}}\\\\\n\\frac{d\\mathbf{k}}{dt} &= -\\frac{\\partial \\omega}{\\partial \\mathbf{q}}\n\\end{aligned}\n\nwhere \\mathbf{q} is the ray position, \\mathbf{k} is the wave vector, and \\omega is the angular frequency. The wave vector and angular frequency are related by\n\n(2)\n\n\\omega = \\frac{c\\left|\\mathbf{k}\\right|}{n}\n\nwhere c is the speed of light in a vacuum. In an absorbing medium, the refractive index can be expressed as n-i\\kappa, in which n and \\kappa are real-valued quantities.\n\nAs the rays enter and leave the lenses, they undergo refraction according to Snell’s Law,\n\n(3)\n\nn_1 \\sin(\\theta_1) = n_2 \\sin(\\theta_2)\n\nwhere \\theta_1 and \\theta_2 are the angle of incidence and the angle of refraction, respectively.\n\nThe intensity and power of the refracted rays are computed using the Fresnel Equations. In most industrial laser focusing systems, an anti-reflective coating is applied to the surfaces of the lenses to prevent large amounts of radiation from being reflected.\n\nIn this example, the anti-reflective coating is modeled by applying a Thin Dielectric Film node to the surfaces of the lenses.\n\n#### Computing the Power Transmitted by Each Ray\n\nThe variables that are used to compute ray intensity are controlled by the “Intensity computation” combobox in the settings window for the Geometrical Optics interface. To compute a heat source using the energy lost by the rays, select “Using principal curvatures and ray power”.", null, "The total power transmitted by each ray, Q, remains constant in non-absorbing domains. In a homogeneous, absorbing domain, the power decays exponentially,\n\n(4)\n\nQ(\\mathbf{r})=Q(\\mathbf{r}_0)\\exp\\left(-2k_0 \\kappa\\left|\\mathbf{r}-\\mathbf{r}_0\\right|\\right)\n\nwhere k_0 is the free-space wave number of the ray.\n\nIn order to apply the power lost by the rays as a source term in the Heat Transfer in Solids interface, it is necessary to add a Deposited Ray Power node to the absorbing domains. This node defines a variable Q_{\\textrm{src}} (SI unit: W/m^3) for the volumetric heat source due to ray attenuation in the selected domains. As the rays propagate through the lenses, they contribute to the value of Q_{\\textrm{src}},\n\n(5)\n\n\\frac{dQ_{\\textrm{src}}}{dt} = -\\sum_{j=1}^{N_t} \\frac{dQ_j}{dt}\\delta(\\mathbf{r}-\\mathbf{q}_j)\n\nwhere Q_{j} (SI unit: W) is the power transmitted by the ray with index j, N_t is the total number of rays, and \\delta is the Dirac delta function. In practice, each ray cannot generate a heat source term at its precise location because the rays occupy infinitesimally small points in space, whereas the underlying mesh elements have finite size, so the power lost by each ray is uniformly distributed over the mesh element the ray is currently in.\n\nThe following short animation illustrates how the heat source defined on domain mesh elements (top) is increased as the power transmitted by each ray (bottom) is reduced.\n\n#### Computing the Temperature\n\nThe temperature in the lens, T, can be computed by solving the heat equation,\n\n(6)\n\n\\nabla \\cdot \\left(-k\\nabla T\\right) = Q_{\\textrm{src}}\n\nwhere k is the thermal conductivity of the medium. A Heat Flux node is used to apply convective cooling at all boundaries that are exposed to the surrounding air,\n\n(7)\n\n-\\mathbf{n}\\cdot\\left(-k\\nabla T\\right) = h\\left(T_{\\textrm{ext}}-T\\right)\n\n#### Structural Deformation\n\nAs the temperature changes, it contributes a thermal strain term \\epsilon_{\\textrm{th}} to the total inelastic strain in the lenses. The thermal strain is defined as\n\n(8)\n\n\\epsilon_{\\textrm{th}}=\\alpha\\left(T-T_{\\textrm{ref}}\\right)\n\nwhere \\alpha is the thermal expansion coefficient, T is the temperature of the medium, and T_{\\textrm{ref}} is the reference temperature. The resulting displacement field \\mathbf{u} is then computed by the Solid Mechanics interface.\n\n### Obtaining a Self-Consistent Solution\n\nIf the power transmitted by the beam is very low, then the energy lost by the rays to their surroundings does not noticeably change the temperature of the medium. However, it is still possible for other phenomena, such as external forces and heat sources, to change the shape or temperature of the lenses.\n\nIn this case, it is necessary to first compute the displacement field and temperature in the domain, and then compute the ray trajectories. This is considered a unidirectional, or one-way, coupling because the temperature change and structural deformation can affect the ray trajectories, but not the other way around.\n\nIf the power transmitted by the beam is sufficiently large, then the dissipation of energy in an absorbing medium may generate enough heat to noticeably change the shape of the domain or the refractive index in the medium. In this case, the ray trajectories affect variables, such as temperature, that are defined on the surrounding domain, and these variables in turn affect the ray trajectories. This is considered a bidirectional, or two-way, coupling.\n\nIn this example, we assume that the laser is operating at constant power, so it is preferable to compute the temperature and displacement field using a Stationary study step. However, the ray trajectories are computed in the time domain.\n\nTo set up a bidirectional coupling between the ray trajectories and the temperature and displacement fields, we first create a Stationary study step to model the heating and deformation of the lenses, then add a Ray Tracing study step to compute the ray trajectories. Then, the corresponding solvers are enclosed within a loop using the For and End For nodes. The following image shows the solver sequence that is used to set up a bidirectional coupling between the ray trajectories and the temperature and displacement fields.", null, "The nodes between the For and End For nodes are repeated a number of times that is specified in the settings window for the For node. Furthermore, every time a solver is run, it uses the solution from the previous solver. In this way, it is possible to set up a bidirectional coupling between the two studies and iterate between them until a self-consistent solution is reached.\n\n### Results of Our Thermal Lensing Model\n\nWe now examine the ray trajectories close to the target for two cases: A 1-watt beam and a 3,000-watt beam.\n\nFor the 1-watt beam, we observe that the focal point of the beam is extremely close to the target surface. The rays do not converge to a single point due to spherical aberration. For the 3,000-watt beam, we see that the beam has already started to diverge by the time it reaches the target surface. The following image compares the deposited ray power at the target for the two cases.", null, "Comparison of the deposited ray power for a 3,000-watt beam (left) and 1-watt beam (right). For comparison and visualization purposes, the color expression for deposited power has been normalized and plotted on a logarithmic scale.\n\nThe Geometrical Optics interface also includes built-in operators for evaluating the sum, average, maximum, or minimum of an expression over all rays. Using these operators, it is possible to quantify the beam width in a variety of ways. As shown in the plot below, the 3,000-watt beam is focused more than 2 millimeters away from the target surface.", null, "We have seen that the temperature change and the resulting thermal expansion in a high-powered laser system can significantly shift the focal point of the beam. With the Ray Optics Module, it is possible to take thermally induced focal shift into account when designing such systems.\n\nTo learn more about computing ray trajectories in thermally deformed lens systems, please refer to the Thermal Lensing in High-Power Laser Focusing Systems model.\n\n#### Categories", null, "##### Victoria Leoni\nApril 22, 2016", null, "##### mona aghaee\nJanuary 29, 2018\n\nHi,\nI have problem modeling radiation heat transfer in a slab. A constant radiation hits an slab and part of that is transferred through the slab, part is absorbed within the slab and part is reflected. How should I model this? I already know the absorptance, reflectance and transmittance coefficients of the slab. Please advise.\n\nThanks\n\nMona\n\nEXPLORE COMSOL BLOG" ]

[ null, "https://cdn.comsol.com/company/logo/comsol-logo-130x20.png", null, "https://cdn.comsol.com/wordpress/sites/1/2018/09/COMSOL_Blog_Header_Electrical.png", null, "https://cdn.comsol.com/wordpress/2014/11/Schematic-of-ray-trajectories.png", null, "https://cdn.comsol.com/wordpress/2014/11/Thermal-lensing-example.png", null, "https://cdn.comsol.com/wordpress/2014/11/Laser-focusing-system-geometry.png", null, "https://cdn.comsol.com/wordpress/2014/11/Ray-trajectories-in-lens.png", null, "https://cdn.comsol.com/wordpress/2014/11/Physics-interfaces-and-nodes.png", null, "https://cdn.comsol.com/wordpress/2014/11/Geometrical-optics-settings.png", null, "https://cdn.comsol.com/wordpress/2014/11/For-and-End-For-nodes.png", null, "https://cdn.comsol.com/wordpress/2014/11/Deposited-ray-power.png", null, "https://cdn.comsol.com/wordpress/2014/11/Plot-of-average-beam-size.png", null, "https://gravatar.com/avatar/00000000000000000000000000000000", null, "https://gravatar.com/avatar/00000000000000000000000000000000", null ]

[ "# Data sets for \"Structure of molten NaCl and the decay of the pair-correlations\"\n\nData sets used to prepare Figure 1 -14 in the Journal of Chemical Physics article entitled \"Structure of molten NaCl and the decay of the pair-correlations.\" The data sets refer to the measured and simulated structure and thermodynamic properties of molten NaCl.\n\nKeywords:\n, , , , ,\nSubjects:\nAtomic and molecular physics\nChemical synthesis\nFacility Development\nMaterials sciences\n\nCite this dataset as:\nSalmon, P., Zeidler, A., 2022. Data sets for \"Structure of molten NaCl and the decay of the pair-correlations\". Bath: University of Bath Research Data Archive. Available from: https://doi.org/10.15125/BATH-01165.\n\n## Export", null, "## Data\n\nFig1_conditioning.agr\ntext/plain (109kB)\n\nFigure 1 shows the k-dependence of the singular values sigma_l (l = 1, 2 or 3) and the condition numbers kappa_2 and kappa_2' for the Faber-Ziman (FZ) (left column) and Bhatia-Thortnon (BT) (right column) partial structure factors.\n\nFig2_n0+newpim_v3.agr\ntext/plain (35kB)\n\nFigure 2 shows the temperature dependence of the atomic number density of the melt from experiment and from molecular dynamics simulations.\n\nFig3_totals.agr\ntext/plain (50kB)\n\nFigure 3 shows neutron total structure factors ^{35}F(k) and ^{nat}F(k) and the difference function Delta F(k) measured for NaCl at 1093 K compared to the x-ray total structure factor S_X(k) measured for NaCl at 1091~K. Also shown is the S_X(k) function measured for NaCl at 1083~K in the work of Ohno and Furukawa.\n\nFig4_sk_pim … forpaper_v2.agr\ntext/plain (171kB)\n\nFigure 4 shows the Faber-Ziman partial structure factors from the present diffraction work at T = 1093 K, the neutron diffraction work of Biggin and Enderby at T = 1148 K and the polarizable ion model (PIM) simulation at T = 1100 K.\n\nFig5a_snn+expt+fit_v2.agr\ntext/plain (86kB)\n\nFigure 5a shows the BT partial structure factor S^{BT}_{NN}(k) from experiment at T = 1100 K and the PIM simulation at T = 1100 K. Also shown is the breakdown of the simulated function into its contributions from the weighted Faber-Ziman partial structure factors S^{FZ}_{ClCl}(k), S^{FZ}_{NaCl}(k) and S^{FZ}_{NaNa}(k). The inset highlights the measured and simulated BT functions at low-k, plotted as a function of k^2 in order to extract the low-order moments by fitting a straight line.\n\nFig5b_scc+expt … ected+fit_v2.agr\ntext/plain (87kB)\n\nFigure 5b shows the BT partial structure factor S^{BT}_{CC}(k) from experiment at T = 1100 K and the PIM simulation at T = 1100 K. Also shown is the breakdown of the simulated function into its contributions from the weighted Faber-Ziman partial structure factors S^{FZ}_{ClCl}(k), S^{FZ}_{NaCl}(k) and S^{FZ}_{NaNa}(k). The inset highlights the measured and simulated BT functions at low-k, plotted as a function of k^2 in order to extract the low-order moments by fitting a straight line.\n\nFig5c_snc+expt+fit_v2.agr\ntext/plain (86kB)\n\nFigure 5b shows the BT partial structure factor S^{BT}_{NC}(k) from experiment at T = 1100 K and the PIM simulation at T = 1100 K. Also shown is the breakdown of the simulated function into its contributions from the weighted Faber-Ziman partial structure factors S^{FZ}_{ClCl}(k), S^{FZ}_{NaCl}(k) and S^{FZ}_{NaNa}(k). The inset highlights the measured and simulated BT functions at low-k, plotted as a function of k^2 in order to extract the low-order moments by fitting a straight line.\n\nFig6_rdf_pim+expt_forpaper_v4.agr\ntext/plain (917kB)\n\nFigure 6 shows the partial pair-distribution functions from the present diffraction work at T = 1093 K, the neutron diffraction work of Biggin and Enderby at T = 1148 K and the PIM simulation at T = 1100 K.\n\nFig8_bt_moments_1100k.agr\ntext/plain (185kB)\n\nFigure 8 shows the running moments ^{run}M_{IJ}^(0)(r_{max}) from the PIM simulations at T = 1100 K for IJ= NN, CC and NC.\n\nFig9_compress+expt_v3.agr\ntext/plain (40kB)\n\nFigure 9 shows the temperature dependence of the isothermal compressibility.\n\nFig10_sal_2rim+pim_v3.agr\ntext/plain (141kB)\n\nFigure 10 shows the Faber-Ziman partial structure factors calculated for molten NaCl at T=1100 K using the PIM, rigid ion model 1 (RIM1) and rigid ion model 2 (RIM2).\n\nFig11a_snn+expt_rim+pim+inset_v2.agr\ntext/plain (140kB)\n\nFigure 11a shows the number-number Bhatia-Thornton partial structure factor calculated for molten NaCl at T = 1100 K using the PIM, RIM1 and RIM2. Also shown is the function measured in the present diffraction work. The inset zooms into the low-k region of the simulated and measured functions.\n\nFig11b_scc+expt_rim+pim_v2.agr\ntext/plain (140kB)\n\nFigure 11b shows the concentration-concentration Bhatia-Thornton partial structure factor calculated for molten NaCl at T = 1100 K using the PIM, RIM1 and RIM2. Also shown is the function measured in the present diffraction work. The inset zooms into the low-k region of the simulated and measured functions.\n\nFig11c_snc+expt_rim+pim_v2.agr\ntext/plain (107kB)\n\nFigure 11c shows the number-concentration Bhatia-Thornton partial structure factor calculated for molten NaCl at T = 1100 K using the PIM, RIM1 and RIM2. Also shown is the function measured in the present diffraction work.\n\nFig12_rh_rim2+fits_v2.agr\ntext/plain (459kB)\n\nFigure 12 shows the total pair correlation functions obtained from the RIM2 simulations at T = 1100 K.\n\nFig13a_rhnn_4t.agr\ntext/plain (351kB)\n\nFigure 13a shows the temperature dependence of the BT total pair-correlation function rh^{BT}_{NN}(r) from the PIM simulations fitted to Eq.~(42).\n\nFig13b_rhcc_4t.agr\ntext/plain (332kB)\n\nFigure 13b shows the temperature dependence of the BT total pair-correlation function rh^{BT}_{CC}(r) from the PIM simulations fitted to Eq.~(42).\n\nFig13c_rhnc_4t.agr\ntext/plain (341kB)\n\nFigure 13c shows the temperature dependence of the BT total pair-correlation function rh^{BT}_{NC}(r) from the PIM simulations fitted to Eq.~(42).\n\nFig14_ero_fits_v2.agr\ntext/plain (18kB)\n\nFigure 14 shows the temperature dependence of the decay length [a_0^{IJ}]^{-1} of Eq.~(42). The values from the PIM simulations at several different temperatures are compared to the values from the diffraction experiment at T = 1093 K.\n\nFig7a_gnn_v3.jpg\nimage/jpeg (281kB)\n\nFigure 7a shows the Bhatia-Thornton partial pair-distribution function g^{BT}_{NN}(r) from the present diffraction work and from the PIM simulation. Also shown is the breakdown of the simulated function into its contributions from the weighted g_{NaCl}(r), g_{ClCl}(r) and g_{NaNa}(r) functions.\n\nFig7b_gcc_v3.jpg\nimage/jpeg (298kB)\n\nFigure 7b shows the Bhatia-Thornton partial pair-distribution function g^{BT}_{CC}(r) from the present diffraction work and from the PIM simulation. Also shown is the breakdown of the simulated function into its contributions from the weighted g_{NaCl}(r), g_{ClCl}(r) and g_{NaNa}(r) functions.\n\nFig7c_gnc_v3.jpg\nimage/jpeg (324kB)\n\nFigure 7c shows the Bhatia-Thornton partial pair-distribution function g^{BT}_{NC}(r) from the present diffraction work and from the PIM simulation. Also shown is the breakdown of the simulated function into its contributions from the weighted g_{NaCl}(r), g_{ClCl}(r) and g_{NaNa}(r) functions.\n\n## Creators\n\nPhilip Salmon\nUniversity of Bath\n\nAnita Zeidler\nUniversity of Bath\n\n## Contributors\n\nMark Wilson\nUniversity of Oxford\n\nUniversity of Bath\nRights Holder\n\n## Coverage\n\nCollection date(s):\n\nFrom 7 May 2007 to 23 June 2022\n\n## Documentation\n\nData collection method:\n\nThe data sets were collected using the methods described in the published paper.\n\nData processing and preparation activities:\n\nThe data sets were analysed using the methods described in the published paper.\n\nTechnical details and requirements:\n\nThe figures were prepared using QtGrace (https://sourceforge.net/projects/qtgrace/). The data set corresponding to a plotted curve within an QtGrace file can be identified by clicking on that curve.\n\nThe files are labelled according to the corresponding figure numbers. The units for each axis are identified on the plots.\n\nZeidler, A., Salmon, P. S., Usuki, T., Kohara, S., Fischer, H. E., and Wilson, M., 2022. Structure of molten NaCl and the decay of the pair-correlations. The Journal of Chemical Physics, 157(9), 094504. Available from: https://doi.org/10.1063/5.0107620.\n\n## Funders\n\nEngineering and Physical Sciences Research Council (EPSRC)\nhttps://doi.org/10.13039/501100000266\n\nGlassy and Liquid Networks: Deformability and Manipulation\nEP/G008795/1\n\nJapan Society for the Promotion of Science (JSPS)\nhttps://doi.org/10.13039/501100001691\n\nGrant\n20H02430\n\nJapan Society for the Promotion of Science (JSPS)\nhttps://doi.org/10.13039/501100001691\n\nGrant\n16H03903\n\n## Publication details\n\nPublication date: 26 August 2022\nby: University of Bath\n\nVersion: 1\n\nURL for this record: https://researchdata.bath.ac.uk/id/eprint/1165\n\n## Related papers and books\n\nZeidler, A., Salmon, P. S., Usuki, T., Kohara, S., Fischer, H. E., and Wilson, M., 2022. Structure of molten NaCl and the decay of the pair-correlations. The Journal of Chemical Physics, 157(9), 094504. Available from: https://doi.org/10.1063/5.0107620." ]

[ null, "https://researchdata.bath.ac.uk/1165/", null ]

[ "## Collecting all my little matlab-like Maxima widgets in one place\n\nSince I’ve been using Maxima (circa 2016), I’ve occasionally missed some little feature from matlab and coded up a replacement for maxima, with a corresponding blog piece here at the Maximalist.\n\nSome examples are find(), diff(), pause(), size(), cumsum(), diag(), and a few list indexing utilities. Also a help() utility that mimics matlab.\n\nHere’s a mac file with all of those in one easy-to-load place: matlabesque.mac\n\nIts help() entry reads like this:\n\n``````matlabesque.mac contains:\nfind(exp)\nithruj(L,i,j)\nindexby(L,indexlist)\nmatlab_diff(L)\npause([options])\ncumsum(l)\nsize(M)\ndiag(M)\n-\n-\nfor any of the above functions,\nhelp(function_name) returns help lines for function_name``````" ]

[ null ]

[ "# 如何使用php在数据库的DateTime列类型中插入日期时间对象\n\nI want to insert a DateTime object in database where the column type is DateTime. How can I achieve this?\n\nI am using this code:\n\n`````` \\$cdate = new DateTime('now')\n\\$cd = \\$cdate->format('d/m/Y h:i:sa')\n\\$udate = new DateTime('72 hours');\n\\$ud = \\$udate->format('d/m/Y h:i:sa')\n\\$insert = \"insert into `winpc_user(mac_address,reg_date,updated_date,status,processor_name,ram_size,os_Name, os_Bits) values('\\$mac','\\$cdate','\\$udate','\\$stat','\\$proName','\\$rSize','\\$osName','\\$osBits')\"\n``````\n• 点赞\n• 写回答\n• 关注问题\n• 收藏\n• 复制链接分享\n• 邀请回答\n\n#### 1条回答\n\n• Same as the comment above, `DATETIME`'s format is:\n\n``````YYYY-MM-DD HH:MM:SS\n``````\n\nQuite straightforward to follow using `date()`'s format function, it'll share the same with the `->format()`:\n\n``````->format('Y-m-d H:i:s');\n``````\n\nSidenote: Of course, this needs to be quoted as well on insertion.\n\nAs an alternative, you could also use MySQL functions to achieve the same goal:\n\n``````NOW()" ]

[ null ]

[ "Solutions by everydaycalculation.com\n\n## Compare 18/35 and 2/20\n\n18/35 is greater than 2/20\n\n#### Steps for comparing fractions\n\n1. Find the least common denominator or LCM of the two denominators:\nLCM of 35 and 20 is 140\n\nNext, find the equivalent fraction of both fractional numbers with denominator 140\n2. For the 1st fraction, since 35 × 4 = 140,\n18/35 = 18 × 4/35 × 4 = 72/140\n3. Likewise, for the 2nd fraction, since 20 × 7 = 140,\n2/20 = 2 × 7/20 × 7 = 14/140\n4. Since the denominators are now the same, the fraction with the bigger numerator is the greater fraction\n5. 72/140 > 14/140 or 18/35 > 2/20\n\nMathStep (Works offline)", null, "Download our mobile app and learn to work with fractions in your own time:" ]

[ null, "https://answers.everydaycalculation.com/mathstep-app-icon.png", null ]

[ "# Shallow copy of a struct\n\nI have a set of mutable structures that are derived from an abstract type :\n\n``````T1 <: AbstractT\nT2 <: AbstractT\nT3 <: AbstractT\n...\nTn <: AbstractT\n``````\n\nI need to make a backup of an array of instances of these structures. I could write a `copy` function (shallow copy) for each struct but I would like to avoid it and write a `copy` function for the abstract type. The problem is that I don’t know how to create an uninitialized instance of a concrete type. Is there a way to instantiate a structure with undefined fields? so later I can make the assignments.\nI was thinking in a copy function like this:\n\n``````function Base.copy(src::AbstractT)\ndst = make_an_uninit_istance_of(typeof(src)) # <= is there a way to do this?\nnames = fieldnames(typeof(src))\nfor name in names\nval = getfield(src, name)\nsetfield!(dst, name, val)\nend\nreturn dst\nend\n``````\n\nIs it possible? Any ideas?\n\n1 Like\n``````julia> Base.@pure _fieldcount(::Type{T}) where T = fieldcount(T)\n\njulia> mycopy(instance::typ) where typ = typ(ntuple(i->getfield(instance, i), _fieldcount(typ))...)\n\njulia> using BenchmarkTools\n\njulia> mutable struct foo\nx1::Int\nx2::Float64\nend\njulia> arr=[foo(1,2.0) for i=1:1000];\njulia> arr2=copy(arr);\njulia> @btime arr2 .= mycopy.(arr);\n8.671 μs (1002 allocations: 31.28 KiB)\n\njulia> othercopy(x)=foo(x.x1, x.x2);\njulia> @btime arr2 .= othercopy.(arr);\n8.582 μs (1002 allocations: 31.28 KiB)\n``````\n1 Like\n\nThanks @foobar_lv2 for the clever suggestion. In my case the structures in the array are of different types (all derived from an abstract type) and have defined constructors thus instantiating by doing `typ(args_tuple...)` is not available. Also, I’d like to define this copy function for the abstract type in order to avoid writing a copy function for each derived type.\n\nI found that deepcopy.jl uses\n\n`````` y = ccall(:jl_new_struct_uninit, Any, (Any,), T)\n``````\n\nto instantiate an uninitialized instance of T.\nIs it ok to use such instruction in a conventional code? Is this interface likely to change in a near future?\n\nI’d warn against taking a naive shallow copies of types with inner constructor. Reason is that inner constructors are used to figure out which fields can be uninitialized, and often contain pointers to external resources that are allocated on construction and cleared by finalizers (memory in external libraries, file descriptors, …). If you take a naive shallow copy then you get into trouble (classic use-after-free: original gets garbage collected, and your copy still holds a reference).\n\nThat being said,\n\n``````julia> ex=:(_genobj(typ)=\\$(Expr(:new, :typ))); eval(ex)\n_genobj (generic function with 1 method)\n\njulia> mutable struct some_typ\na::Int\nb::Vector{Int}\nend\njulia> _genobj(some_typ)\nsome_typ(1, #undef)\n``````\n\nThis is somewhat invalid (but your ccall scheme should be just as invalid): We are lying to the compiler about uninitialized fields. The lack of inner constructor told the compiler that `b` is always initialized; but it isn’t because `_genobj` is not quite valid julia:\n\n``````julia> arr=[_genobj(some_typ) for i=1:100];\njulia> t(arr,i)=arr[i].b\njulia> t(arr,5)\n\nsignal (11): Segmentation fault\n``````\n\nJust dispatch `Base.copy(x::AbstractT) = mycopy(x)` for whatever scheme you decide on.\n\n1 Like" ]

[ null ]

[ "", null, "GeeksforGeeks App\nOpen App", null, "Browser\nContinue\n\n# Euler Circuit in a Directed Graph\n\nEulerian Path is a path in graph that visits every edge exactly once. Eulerian Circuit is an Eulerian Path which starts and ends on the same vertex.\n\nA graph is said to be eulerian if it has a eulerian cycle. We have discussed eulerian circuit for an undirected graph. In this post, the same is discussed for a directed graph.\n\nFor example, the following graph has eulerian cycle as {1, 0, 3, 4, 0, 2, 1}", null, "How to check if a directed graph is eulerian?\n\nA directed graph has an eulerian cycle if following conditions are true\n\n1. All vertices with nonzero degree belong to a single strongly connected component\n2. In degree is equal to the out degree for every vertex.\n\nWe can detect singly connected component using Kosaraju’s DFS based simple algorithm\n\nTo compare in degree and out-degree, we need to store in degree and out-degree of every vertex. Out degree can be obtained by the size of an adjacency list. In degree can be stored by creating an array of size equal to the number of vertices.\n\nFollowing implementations of above approach.\n\n## C++\n\n `// A C++ program to check if a given directed graph is Eulerian or not``#include``#include ``#define CHARS 26``using` `namespace` `std;` `// A class that represents an undirected graph``class` `Graph``{``    ``int` `V;    ``// No. of vertices``    ``list<``int``> *adj;    ``// A dynamic array of adjacency lists``    ``int` `*in;``public``:``    ``// Constructor and destructor``    ``Graph(``int` `V);``    ``~Graph()   { ``delete` `[] adj; ``delete` `[] in; }` `    ``// function to add an edge to graph``    ``void` `addEdge(``int` `v, ``int` `w) { adj[v].push_back(w);  (in[w])++; }` `    ``// Method to check if this graph is Eulerian or not``    ``bool` `isEulerianCycle();` `    ``// Method to check if all non-zero degree vertices are connected``    ``bool` `isSC();` `    ``// Function to do DFS starting from v. Used in isConnected();``    ``void` `DFSUtil(``int` `v, ``bool` `visited[]);` `    ``Graph getTranspose();``};` `Graph::Graph(``int` `V)``{``    ``this``->V = V;``    ``adj = ``new` `list<``int``>[V];``    ``in = ``new` `int``[V];``    ``for` `(``int` `i = 0; i < V; i++)``       ``in[i] = 0;``}` `/* This function returns true if the directed graph has a eulerian``   ``cycle, otherwise returns false  */``bool` `Graph::isEulerianCycle()``{``    ``// Check if all non-zero degree vertices are connected``    ``if` `(isSC() == ``false``)``        ``return` `false``;` `    ``// Check if in degree and out degree of every vertex is same``    ``for` `(``int` `i = 0; i < V; i++)``        ``if` `(adj[i].size() != in[i])``            ``return` `false``;` `    ``return` `true``;``}` `// A recursive function to do DFS starting from v``void` `Graph::DFSUtil(``int` `v, ``bool` `visited[])``{``    ``// Mark the current node as visited and print it``    ``visited[v] = ``true``;` `    ``// Recur for all the vertices adjacent to this vertex``    ``list<``int``>::iterator i;``    ``for` `(i = adj[v].begin(); i != adj[v].end(); ++i)``        ``if` `(!visited[*i])``            ``DFSUtil(*i, visited);``}` `// Function that returns reverse (or transpose) of this graph``// This function is needed in isSC()``Graph Graph::getTranspose()``{``    ``Graph g(V);``    ``for` `(``int` `v = 0; v < V; v++)``    ``{``        ``// Recur for all the vertices adjacent to this vertex``        ``list<``int``>::iterator i;``        ``for``(i = adj[v].begin(); i != adj[v].end(); ++i)``        ``{``            ``g.adj[*i].push_back(v);``            ``(g.in[v])++;``        ``}``    ``}``    ``return` `g;``}` `// This function returns true if all non-zero degree vertices of``// graph are strongly connected (Please refer``// https://www.geeksforgeeks.org/connectivity-in-a-directed-graph/ )``bool` `Graph::isSC()``{``    ``// Mark all the vertices as not visited (For first DFS)``    ``bool` `visited[V];``    ``for` `(``int` `i = 0; i < V; i++)``        ``visited[i] = ``false``;` `    ``// Find the first vertex with non-zero degree``    ``int` `n;``    ``for` `(n = 0; n < V; n++)``        ``if` `(adj[n].size() > 0)``          ``break``;` `    ``// Do DFS traversal starting from first non zero degrees vertex.``    ``DFSUtil(n, visited);` `     ``// If DFS traversal doesn't visit all vertices, then return false.``    ``for` `(``int` `i = 0; i < V; i++)``        ``if` `(adj[i].size() > 0 && visited[i] == ``false``)``              ``return` `false``;` `    ``// Create a reversed graph``    ``Graph gr = getTranspose();` `    ``// Mark all the vertices as not visited (For second DFS)``    ``for` `(``int` `i = 0; i < V; i++)``        ``visited[i] = ``false``;` `    ``// Do DFS for reversed graph starting from first vertex.``    ``// Starting Vertex must be same starting point of first DFS``    ``gr.DFSUtil(n, visited);` `    ``// If all vertices are not visited in second DFS, then``    ``// return false``    ``for` `(``int` `i = 0; i < V; i++)``        ``if` `(adj[i].size() > 0 && visited[i] == ``false``)``             ``return` `false``;` `    ``return` `true``;``}` `// Driver program to test above functions``int` `main()``{``    ``// Create a graph given in the above diagram``    ``Graph g(5);``    ``g.addEdge(1, 0);``    ``g.addEdge(0, 2);``    ``g.addEdge(2, 1);``    ``g.addEdge(0, 3);``    ``g.addEdge(3, 4);``    ``g.addEdge(4, 0);` `    ``if` `(g.isEulerianCycle())``       ``cout << ``\"Given directed graph is eulerian n\"``;``    ``else``       ``cout << ``\"Given directed graph is NOT eulerian n\"``;``    ``return` `0;``}`\n\n## Java\n\n `// A Java program to check if a given directed graph is Eulerian or not` `// A class that represents an undirected graph``import` `java.io.*;``import` `java.util.*;``import` `java.util.LinkedList;` `// This class represents a directed graph using adjacency list``class` `Graph``{``    ``private` `int` `V;   ``// No. of vertices``    ``private` `LinkedList adj[];``//Adjacency List``    ``private` `int` `in[];            ``//maintaining in degree` `    ``//Constructor``    ``Graph(``int` `v)``    ``{``        ``V = v;``        ``adj = ``new` `LinkedList[v];``        ``in = ``new` `int``[V];``        ``for` `(``int` `i=``0``; i i =adj[v].iterator();``        ``while` `(i.hasNext())``        ``{``            ``n = i.next();``            ``if` `(!visited[n])``                ``DFSUtil(n,visited);``        ``}``    ``}` `    ``// Function that returns reverse (or transpose) of this graph``    ``Graph getTranspose()``    ``{``        ``Graph g = ``new` `Graph(V);``        ``for` `(``int` `v = ``0``; v < V; v++)``        ``{``            ``// Recur for all the vertices adjacent to this vertex``            ``Iterator i = adj[v].listIterator();``            ``while` `(i.hasNext())``            ``{``                ``g.adj[i.next()].add(v);``                ``(g.in[v])++;``            ``}``        ``}``        ``return` `g;``    ``}` `    ``// The main function that returns true if graph is strongly``    ``// connected``    ``Boolean isSC()``    ``{``        ``// Step 1: Mark all the vertices as not visited (For``        ``// first DFS)``        ``Boolean visited[] = ``new` `Boolean[V];``        ``for` `(``int` `i = ``0``; i < V; i++)``            ``visited[i] = ``false``;` `        ``// Step 2: Do DFS traversal starting from the first vertex.``        ``DFSUtil(``0``, visited);` `        ``// If DFS traversal doesn't visit all vertices, then return false.``        ``for` `(``int` `i = ``0``; i < V; i++)``            ``if` `(visited[i] == ``false``)``                ``return` `false``;` `        ``// Step 3: Create a reversed graph``        ``Graph gr = getTranspose();` `        ``// Step 4: Mark all the vertices as not visited (For second DFS)``        ``for` `(``int` `i = ``0``; i < V; i++)``            ``visited[i] = ``false``;` `        ``// Step 5: Do DFS for reversed graph starting from first vertex.``        ``// Starting Vertex must be same starting point of first DFS``        ``gr.DFSUtil(``0``, visited);` `        ``// If all vertices are not visited in second DFS, then``        ``// return false``        ``for` `(``int` `i = ``0``; i < V; i++)``            ``if` `(visited[i] == ``false``)``                ``return` `false``;` `        ``return` `true``;``    ``}` `    ``/* This function returns true if the directed graph has a eulerian``       ``cycle, otherwise returns false  */``    ``Boolean isEulerianCycle()``    ``{``        ``// Check if all non-zero degree vertices are connected``        ``if` `(isSC() == ``false``)``            ``return` `false``;` `        ``// Check if in degree and out degree of every vertex is same``        ``for` `(``int` `i = ``0``; i < V; i++)``            ``if` `(adj[i].size() != in[i])``                ``return` `false``;` `        ``return` `true``;``    ``}` `    ``public` `static` `void` `main (String[] args) ``throws` `java.lang.Exception``    ``{``        ``Graph g = ``new` `Graph(``5``);``        ``g.addEdge(``1``, ``0``);``        ``g.addEdge(``0``, ``2``);``        ``g.addEdge(``2``, ``1``);``        ``g.addEdge(``0``, ``3``);``        ``g.addEdge(``3``, ``4``);``        ``g.addEdge(``4``, ``0``);` `        ``if` `(g.isEulerianCycle())``            ``System.out.println(``\"Given directed graph is eulerian \"``);``        ``else``            ``System.out.println(``\"Given directed graph is NOT eulerian \"``);``    ``}``}``//This code is contributed by Aakash Hasija`\n\n## Python3\n\n `# A Python3 program to check if a given``# directed graph is Eulerian or not` `from` `collections ``import` `defaultdict` `class` `Graph():` `    ``def` `__init__(``self``, vertices):``        ``self``.V ``=` `vertices``        ``self``.graph ``=` `defaultdict(``list``)``        ``self``.IN ``=` `[``0``] ``*` `vertices` `    ``def` `addEdge(``self``, v, u):` `        ``self``.graph[v].append(u)``        ``self``.IN[u] ``+``=` `1` `    ``def` `DFSUtil(``self``, v, visited):``        ``visited[v] ``=` `True``        ``for` `node ``in` `self``.graph[v]:``            ``if` `visited[node] ``=``=` `False``:``                ``self``.DFSUtil(node, visited)` `    ``def` `getTranspose(``self``):``        ``gr ``=` `Graph(``self``.V)` `        ``for` `node ``in` `range``(``self``.V):``            ``for` `child ``in` `self``.graph[node]:``                ``gr.addEdge(child, node)` `        ``return` `gr` `    ``def` `isSC(``self``):``        ``visited ``=` `[``False``] ``*` `self``.V` `        ``v ``=` `0``        ``for` `v ``in` `range``(``self``.V):``            ``if` `len``(``self``.graph[v]) > ``0``:``                ``break` `        ``self``.DFSUtil(v, visited)` `        ``# If DFS traversal doesn't visit all``        ``# vertices, then return false.``        ``for` `i ``in` `range``(``self``.V):``            ``if` `visited[i] ``=``=` `False``:``                ``return` `False` `        ``gr ``=` `self``.getTranspose()` `        ``visited ``=` `[``False``] ``*` `self``.V``        ``gr.DFSUtil(v, visited)` `        ``for` `i ``in` `range``(``self``.V):``            ``if` `visited[i] ``=``=` `False``:``                ``return` `False` `        ``return` `True` `    ``def` `isEulerianCycle(``self``):` `        ``# Check if all non-zero degree vertices``        ``# are connected``        ``if` `self``.isSC() ``=``=` `False``:``            ``return` `False` `        ``# Check if in degree and out degree of``        ``# every vertex is same``        ``for` `v ``in` `range``(``self``.V):``            ``if` `len``(``self``.graph[v]) !``=` `self``.IN[v]:``                ``return` `False` `        ``return` `True`  `g ``=` `Graph(``5``);``g.addEdge(``1``, ``0``);``g.addEdge(``0``, ``2``);``g.addEdge(``2``, ``1``);``g.addEdge(``0``, ``3``);``g.addEdge(``3``, ``4``);``g.addEdge(``4``, ``0``);``if` `g.isEulerianCycle():``   ``print``( ``\"Given directed graph is eulerian\"``);``else``:``   ``print``( ``\"Given directed graph is NOT eulerian\"``);` `# This code is contributed by Divyanshu Mehta`\n\n## C#\n\n `// A C# program to check if a given``// directed graph is Eulerian or not` `// A class that represents an``// undirected graph``using` `System;``using` `System.Collections.Generic;` `// This class represents a directed``// graph using adjacency list``class` `Graph{``    ` `// No. of vertices``public` `int` `V;  ` `// Adjacency List``public` `List<``int``> []adj;` `// Maintaining in degree``public` `int` `[]init;          ` `// Constructor``Graph(``int` `v)``{``    ``V = v;``    ``adj = ``new` `List<``int``>[v];``    ``init = ``new` `int``[V];``    ` `    ``for``(``int` `i = 0; i < v; ++i)``    ``{``        ``adj[i] = ``new` `List<``int``>();``        ``init[i]  = 0;``    ``}``}` `// Function to add an edge into the graph``void` `addEdge(``int` `v, ``int` `w)``{``    ``adj[v].Add(w);``    ``init[w]++;``}` `// A recursive function to print DFS``// starting from v``void` `DFSUtil(``int` `v, Boolean []visited)``{``    ` `    ``// Mark the current node as visited``    ``visited[v] = ``true``;` `    ``// Recur for all the vertices``    ``// adjacent to this vertex``    ``foreach``(``int` `i ``in` `adj[v])``    ``{``        ` `        ``if` `(!visited[i])``            ``DFSUtil(i, visited);``    ``}``}` `// Function that returns reverse``// (or transpose) of this graph``Graph getTranspose()``{``    ``Graph g = ``new` `Graph(V);``    ``for``(``int` `v = 0; v < V; v++)``    ``{``        ` `        ``// Recur for all the vertices``        ``// adjacent to this vertex``        ``foreach``(``int` `i ``in` `adj[v])``        ``{``            ``g.adj[i].Add(v);``            ``(g.init[v])++;``        ``}``    ``}``    ``return` `g;``}` `// The main function that returns``// true if graph is strongly connected``Boolean isSC()``{``    ` `    ``// Step 1: Mark all the vertices``    ``// as not visited (For first DFS)``    ``Boolean []visited = ``new` `Boolean[V];``    ``for``(``int` `i = 0; i < V; i++)``        ``visited[i] = ``false``;` `    ``// Step 2: Do DFS traversal starting``    ``// from the first vertex.``    ``DFSUtil(0, visited);` `    ``// If DFS traversal doesn't visit``    ``// all vertices, then return false.``    ``for``(``int` `i = 0; i < V; i++)``        ``if` `(visited[i] == ``false``)``            ``return` `false``;` `    ``// Step 3: Create a reversed graph``    ``Graph gr = getTranspose();` `    ``// Step 4: Mark all the vertices as``    ``// not visited (For second DFS)``    ``for``(``int` `i = 0; i < V; i++)``        ``visited[i] = ``false``;` `    ``// Step 5: Do DFS for reversed graph``    ``// starting from first vertex.``    ``// Starting Vertex must be same``    ``// starting point of first DFS``    ``gr.DFSUtil(0, visited);` `    ``// If all vertices are not visited``    ``// in second DFS, then return false``    ``for``(``int` `i = 0; i < V; i++)``        ``if` `(visited[i] == ``false``)``            ``return` `false``;` `    ``return` `true``;``}` `// This function returns true if the``// directed graph has a eulerian``// cycle, otherwise returns false ``Boolean isEulerianCycle()``{``    ` `    ``// Check if all non-zero degree``    ``// vertices are connected``    ``if` `(isSC() == ``false``)``        ``return` `false``;` `    ``// Check if in degree and out``    ``// degree of every vertex is same``    ``for``(``int` `i = 0; i < V; i++)``        ``if` `(adj[i].Count != init[i])``            ``return` `false``;` `    ``return` `true``;``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``Graph g = ``new` `Graph(5);``    ``g.addEdge(1, 0);``    ``g.addEdge(0, 2);``    ``g.addEdge(2, 1);``    ``g.addEdge(0, 3);``    ``g.addEdge(3, 4);``    ``g.addEdge(4, 0);``    ` `    ``if` `(g.isEulerianCycle())``        ``Console.WriteLine(``\"Given directed \"` `+``                          ``\"graph is eulerian \"``);``    ``else``        ``Console.WriteLine(``\"Given directed \"` `+``                          ``\"graph is NOT eulerian \"``);``}``}` `// This code is contributed by Princi Singh`\n\n## Javascript\n\n ``\n\nOutput\n\n`Given directed graph is eulerian n`\n\nTime complexity of the above implementation is O(V + E) as Kosaraju’s algorithm takes O(V + E) time. After running Kosaraju’s algorithm we traverse all vertices and compare in degree with out degree which takes O(V) time.\n\nAuxiliary Space : O(V), since an extra visited array of size V is required.\n\nSee following as an application of this.\nFind if the given array of strings can be chained to form a circle.\n\nMy Personal Notes arrow_drop_up" ]

[ null, "https://media.geeksforgeeks.org/gfg-gg-logo.svg", null, "https://media.geeksforgeeks.org/auth-dashboard-uploads/web-2.png", null, "https://media.geeksforgeeks.org/wp-content/cdn-uploads/SCC1.png", null ]

[ "Plot x-axis and y-axis with mexCallmatlab\n\n1 view (last 30 days)\nAlex on 24 Aug 2013\nHello,\nIn my S-function written in C I use the function mexCallmatlab to plot the content of an array and it works as I want:\nreal_T Gain;\n// Some code to fill the array Gain\n// convert array to mxArray\nmxArray* x_ptr_gain; // Pointer\nx_ptr_gain = mxCreateDoubleMatrix(1, 205, mxREAL);\nmemcpy(mxGetPr(x_ptr_gain), Gain, sizeof(double)*205);\nmexCallMATLAB(0,NULL,1,&x_ptr_gain,\"plot\");\nMatlab plots on the y-axis the content of my array and on the x-axis the vector number 1,2…205.\nNow I would like to have on the x-axis the content of an other vector freq, which has of course the same size than Gain:\nreal_T freq;\nWhat do I have to change to get want I want? I tried a few things, but as I am not very sure how all these structures work, I may have done mistakes and giving me the solution would be really nice :)\nThanks.\n\nKaustubha Govind on 26 Aug 2013\nYou need to use the plot(x,y) form of PLOT:\n// Copy freq into an mxArray x_ptr_freq\nmxArray* x_ptr_freq = mxCreateDoubleMatrix(1, 205, mxREAL);\nmemcpy(mxGetPr(x_ptr_freq), freq, sizeof(double)*205);\n...\nmxArray *prhs = {x_ptr_freq, x_ptr_gain};\nmexCallMATLAB(0,NULL,2,prhs,\"plot\");\n...\n// Cleanup\nmxDestroyArray(x_ptr_freq);\nmxDestroyArray(x_ptr_gain);" ]

[ null ]

[ "", null, "", null, "", null, "Next: 6.2 Tail-Recursive Fibonacci Up: 6 Analyzing Algorithms Previous: 6 Analyzing Algorithms\n\n## 6.1 Recursive Fibonacci\n\nThe recursive definitions mentioned above all involve trivial linear recursive processes. The next example illustrates the kind of analysis a student might perform on a less trivial problem. Consider the standard recursive definition of the `fibonacci` function.\n\n```fibonacci =: monad define script\nif. y. < 2\ndo. y.\nelse. (fibonacci y. - 1) + fibonacci y. - 2\nend.\n)\n```\n\nProgram `fibonacci` (J Version)\n\nApplying `fibonacci` to the argument 5 produces a result of 5. Tracing `fibonacci` produces the output\n\n``` traced_fibonacci 5\nEntering, input = 5\nEntering, input = 4\nEntering, input = 3\nEntering, input = 2\nEntering, input = 1\nLeaving, result = 1\nEntering, input = 0\nLeaving, result = 0\nLeaving, result = 1\nEntering, input = 1\nLeaving, result = 1\nLeaving, result = 2\nEntering, input = 2\nEntering, input = 1\nLeaving, result = 1\nEntering, input = 0\nLeaving, result = 0\nLeaving, result = 1\nLeaving, result = 3\nEntering, input = 3\nEntering, input = 2\nEntering, input = 1\nLeaving, result = 1\nEntering, input = 0\nLeaving, result = 0\nLeaving, result = 1\nEntering, input = 1\nLeaving, result = 1\nLeaving, result = 2\nLeaving, result = 5\n5\n```\n\nAnalyzing the `fibonacci` definition, we notice that there are two recursive calls to `fibonacci` inside this definition. We next write the continuations of each of these calls.\n\n```monad define 'y. + fibonacci n - 2'\n\nmonad define '(fibonacci n - 1) + y.'\n```\n\n`fibonacci` is not tail recursive. In fact, each continuation contains a recursive call to `fibonacci`. We also notice, from the traced output, that `fibonacci` makes applications of `fibonacci` to the same argument.\n\nConsider the problem of evaluating `fibonacci 3`. Two continuations must be formed.\n\n```c1 =: monad define'y. + fibonacci 0'\nc2 =: monad define'y. + fibonacci 1'\n```\n\nThe value of `fibonacci 3` is represented by the expression `c2 c1 1`. Next, consider the problem of evaluating `fibonacci 4`. Three continuations must be formed.\n\n```c1 =: monad define'y. + fibonacci 0'\nc2 =: monad define'y. + fibonacci 1'\nc3 =: monad define'y. + fibonacci 2'\n```\n\nThe value of `fibonacci 4` is represented by the expression `c3 c2 c1 1`.\n\nNext we consider the number of times `fibonacci` is called while evaluating `fibonacci`. Define `fib_work` to be the number of times `fibonacci` is called while evaluating `fibonacci`. We see that:\n\n• `fib_work 0 = 1`\n• `fib_work 1 = 1`\n• `fib_work 2 = 3`\n• `fib_work 3 = 5`\n• `fib_work 4 = 9`\n• `fib_work 5 = 15`\n\nIt is easy to establish the recurrence formula for `fib_work`\n\n```fib_work n = 1 + (fib_work n - 1) + fib_work n - 2\n```\n\nAssuming that the execution time of `fibonacci` is proportional to `fib_work`, then the order of `fibonacci` is `fib_work` which is, itself, a `fibonacci` function. This analysis leads to a laboratory experiment [How 94] in which students conduct timing measurements of the number of recursive calls per second a workstation can make to `fibonacci`. Since `fibonacci` would make 1146295688027634168201 recursive calls while evaluating `fibonacci 100`, a workstation which can perform 1,000,000 recursive calls per second would require approximately 1146295688027634 seconds (more than 363487 centuries!) to evaluate `fibonacci 100`. This laboratory provides the opportunity for students to deal with formal analysis, experimental measurements, recursion and iteration.", null, "", null, "", null, "Next: 6.2 Tail-Recursive Fibonacci Up: 6 Analyzing Algorithms Previous: 6 Analyzing Algorithms\n2002-11-26" ]

[ null, "http://www.cs.trinity.edu/~jhowland/ccsc98/ccsc98/next.gif", null, "http://www.cs.trinity.edu/~jhowland/ccsc98/ccsc98/up.gif", null, "http://www.cs.trinity.edu/~jhowland/ccsc98/ccsc98/prev.gif", null, "http://www.cs.trinity.edu/~jhowland/ccsc98/ccsc98/next.gif", null, "http://www.cs.trinity.edu/~jhowland/ccsc98/ccsc98/up.gif", null, "http://www.cs.trinity.edu/~jhowland/ccsc98/ccsc98/prev.gif", null ]

[ "# impedance matrix\n\n## impedance matrix\n\n[im′pēd·əns ‚mā·triks]\n(electricity)\nA matrix Z whose elements are the mutual impedances between the various meshes of an electrical network; satisfies the matrix equation V = ZI, where V and I are column vectors whose elements are the voltages and currents in the meshes.\nMcGraw-Hill Dictionary of Scientific & Technical Terms, 6E, Copyright © 2003 by The McGraw-Hill Companies, Inc.\nReferences in periodicals archive ?\nwhere [Z.sub.o,s] is the impedance matrix corresponding to observation group o and source group s; [I.sub.s] is the coefficient vector of RWG basis functions in group s; [B.sub.o] denotes near neighbors of group o; [T.sub.o,s] is the translator; [D.sub.o] and [A.sub.s] are the disaggregation and aggregation matrices.\nThe unknown expansion coefficients [MATHEMATICAL EXPRESSION NOT REPRODUCIBLE IN ASCII] can be related utilizing impedance matrix as follows:\nThe number of columns and raws of the self-impedance matrix [Z.sub.s] and the mutual impedance matrix [Z.sub.m] is N by N.\nThe second one sets the load impedances as the conjugates impedances of the corresponding receiving antennas, the third one sets the impedance matrix of the matching network as the conjugate of antennas' impedance matrix and consider the mutual couplings of the matching network, while the last one optimize the impedances of transmission lines between receivers and loads, but it does not take into account the mutual couplings of the matching network existing practically.\nTo directly generate the impedance matrix, the position vectors of the source points and field points will be repeatedly computed for diferent orders and consumed time.\nAfter modeling a target with a set of N expansion functions and performing the traditional Galerkin testing for the integral equations, a N x N dense impedance matrix is generated.\nwhere j = 1,2,..., n, n is the sum of the connection substructures, [mathematical expression not reproducible] refers to the connection impedance matrix of the jth connection substructure, o denotes the DOF sum of the jth connection substructure, and [z.sub.ab] denotes the connection impedance between ath and bth DOFs that denotes the force needed to act on the bth DOF when the ath DOF happens to be a unit displacement.\nThe total impedance matrix contains two parts: self-coupling blocks and mutual coupling blocks.\nAfter obtaining the reduced admittance matrix, the impedance matrix seen from terminals 1 and 2 is calculated by its inverse.\nwhere [Z] is the system equivalent impedance matrix and [m] is a fully coupling matrix.\nwhere [Z.sup.GP] is the gear pair impedance matrix, [V.sup.GP] is the gear pair velocity vector, [F.sup.GP] is the applied external force vector, and [F.sup.mesh] is the static transmission error excitation force vector.\nand by substitution of (11) into (10), the scattering parameters are now found in terms of impedance matrix as follows,\nSite: Follow: Share:\nOpen / Close" ]

[ null ]

[ "# Cpm homework help pre algebra\n\nCpm homework help pre algebra Rated 5 stars, based on 7 customer reviews From \\$7.51 per page Available! Order now!\n\n## Homework help accounting online\n\nMs davis's pre-algebra blog daily agendas & homework assignments for math 7 & accelerated pre-algebra at nbms.\n\nHelp homework online student\n• Practial algebra lessons: purplemath's algebra lessons are informal in cpm homework help pre algebra their tone, and are written with the struggling student in mind;\n• Studypool helped me so much this semester;\n• Algebra homework engineering economics homework help help by top algebra homework writer;\n• Mathbitsnotebook - algebra 1 is a series of lesson and practice pages for students did you ever buy an essay studying high school algebra 1;\n• Resources; this collection of the mango website as well as your homework help by the vector sum;\n• Typically, parents are paying between to per hour for onsite (home) tutoring;\n\nHomework help algebra calculator, best academic writing. Algebra 1 cpm book answers - bing. You will be pleasantly surprised by the fact that our experts are always ready to offer you a math assignment help. Cpm precalculus homework helper, how to assign static ip address in windows server 2012 free argumentative essay on death penalty best dissertation awards literary interpretation essay example. Materials coo rdinate with sbac, parcc, and state assessments. How to succeed cpm homework help pre algebra in pre-algebra, grades 5-8. These worksheets that it, science ela homework help for you and cheap. Cpm algebra 2 - chapter 12. We suggest that the reasonable and affordable range for parents is between to per hour for online tutoring and live homework help. Homework help algebra 2 - the @kilmerdrama algebra 2 homework help before you read help homework algebra 2 an extended definition of terms theoretical framework based. Math assignment help a+ math solutions (,50/page). Connects students with tutors that can homework help for highschool help them with their homework.\n\nSolving problems with linear systems solver business plan bakery doc thesis statement for cause and effect essays math homework help free math homework for critical thinking critical thinking writing prompts high school texas tech essay deadline 200 words essay about love cpm math homework answers essay.\n\n## Algaebra 2 homework help\n\nLesson 1: using variablesprentice hall cpm homework help pre algebra algebra 2 homework help from. We provide linear algebra homework help and assistance with other types like polynomials, cpm homework help pre algebra matrices, quadratic equations, series and sequences, etc.\n\nHomework help ga\n1. Each topic listed below can have lessons, solvers that show work, an opportunity to ask a free tutor, and the list of questions already answered by the free tutors;\n2. Cpm homework help - academic cpm homework help pre algebra writing help;\n3. Homework help - great help with pre-algebra, algebra and geometry;\n\nMost students connect in 60 seconds or -algebra, algebra i, algebra ii, geometry: homework help by free math tutors, solvers, section has solvers (calculators.\n\nFundamental theorem of algebra help us with graphing functions, college algebra books answers, online calculator for pre algebra, algebra exercises f1. Please fill the form and submit request for essay about cleanliness and orderliness either of the two options. Honors pre calc, math 101, geometry, and algebra homework help australia 2 homework help may be. We cover all topics you will find in any homework help australia typical pre algebra class, florida fsa, s. First in math and homework help math algebra 2 covered call trading journal reflex math: algebra homework help from brilliant professional writers. Really clear math lessons (pre-algebra, algebra, precalculus), cool math.\n\nAlgebra 1a homework help\n1. Pre calc homework help cpm, best cover letter font size;\n2. Here is a graphic preview for all of the systems of equations worksheets;\n3. Algebra homework help, political science homework help algebra solvers, free math tutorsfull curriculum of exercises and videos;\n4. Over 1000 online math lessons aligned to the prentice hall textbooks and featuring a personal math teacher inside every lesson;\n5. Post your homework help homework questions and get answers from qualified tutors;\n\nAlgebra help-the fastest growing online source for help with algebra-calculators, lessons, and resources are designed to help you learn and understand algebra. Glencoe pre-algebra homework practice workbookb. Holt math algebra 2 homework help holtfree shipping on qualified ordersas a member, youll also get unlimited access to over 75,000 lessons in math, english, science, history, and more. These materials cover all standards stated in the common core standards (or next generation standards) for mathematics, and more.\n\nHomework help english literature\n• Get better math mark with our complete pre algebra help;\n• These apps will do your homework cpm homework help pre algebra for you;\n• The development of exhibition in the way the brain than that of a series of related research on teacher education focuses on changing an organization wants to encourage;\n• Cpm homework help: contains answers for homework problems;\n• Work with our scholars to receive the excellent essay following the requirements;\n• We help thousands of students get better grades every day;\n• Cpm homework help cc2 cpm homework help cc2 cpm cc2 homework answers if you are cpm student guidebook cc course 3 etools;\n\nAlgebra of polygons and circles relations and help congruent figures squares and pre medieval homework help the pythagorean theorem and right triangle facts relations and sizes math quiz. Our team includes a pool of experts who are always ready to lend a hand to senior students. Your ta will cpm 3 online resources to help generate more help solving athe logic tutor responds: cpm homework questions, more great. Oliver anticonvulsant and carangoid reports his scourge or maneuver pre algebra math homework help disrespectfully. With this online service, parents can also view a childs cafeteria purchases, make payments for their children even if they attend different schools, and set up automatic email reminders to be notified when a payment is needed. Calculators and solvers for your homework help science cells homework. Work with an expert tutor on-demand or schedule a session in advance. Containing 123 lessons, this text is the culmination of pre-algebra mathematics, a full pre-algebra course and an introduction to geometry and discrete mathematics.\n\n## Cs211 homework help\n\nAcademized worked on my dissertation as jefferson county public schools homework help i didnt have enough time for both doing research and writing. Homework: study for quiz using problems provided above. Get affordable help in your custom assignment papers from our professional writers. Welcome to our \"weather homework help\" webpage. Mcgraw-hill's \"connect\" is a web-based assignment and assessment platform that helps you connect your students to their coursework and to success beyond the course. Cool math has free online cool math lessons, cool math games and fun math activities. Get answers from premium tutors 24/7. See more about cpm cpm pre algebra 1 common core connections new homework help algebra cpm textbooks. Build learning momentum and student confidence with individualized, adaptive learning and assessment correlated to the common core and all 50 states' standards. Myschoolbucks is a website for parents to pay for their childs school meals using a credit or debit card.\n\nSITEMAP" ]

[ null ]

[ "# Estimation of parameters for a non-linear model\n\n27 views (last 30 days)\nAwedBy Matlab on 22 Oct 2013\nAnswered: AwedBy Matlab on 23 Oct 2013\nHi everyone,\nI have a model that relates the average reaction time and error rate from an experimental session, with two free parameters, a and b:\nER=1/(1+a*(lnRT)^b )\nI'm a bit confused by the multitude of ways to do the estimation of a and b. What's the simplest/reliable way to do it?\nMany thanks!\n\nMatt J on 22 Oct 2013\nWhich way do you consider complicated?\nAwedBy Matlab on 22 Oct 2013\nfor instance after reading the help of fminsearch..\n\nJonathan LeSage on 22 Oct 2013\nIf you're using MATLAB 2011b or newer, you likely have access to the Curve Fitting app. If you have this tool installed, you can open it by typing cftool. This tool allows you to import your data and then define a custom equation to fit. Once you've imported your data, you can select \"Custon Equation\" from the fit type menu and define you're own equation to fit. The cftool is probably the most straightforward method for fitting nonlinear curves to experimental data. Here is a link to an introduction to the product and an example.\nAnother option is to use the lsqcurvefit function to perform a nonlinear least squares fit of your custom defined equation using your data. Here is an example of this function being used:\nHopefully this helps to get you started!" ]

[ null ]

[ "Operators\n\n# inpainting_ced (Operator)\n\n## Name\n\ninpainting_ced — Perform an inpainting by coherence enhancing diffusion.\n\n## Signature\n\ninpainting_ced(Image, Region : InpaintedImage : Sigma, Rho, Theta, Iterations : )\n\n## Description\n\nThe operator inpainting_ced performs an anisotropic diffusion process on the region Region of the input image Image with the objective of completing discontinuous image edges diffusively by increasing the coherence of the image structures contained in Image and without smoothing these edges perpendicular to their dominating direction. The mechanism is the same as in the operator coherence_enhancing_diff, which is based on a discretization of the anisotropic diffusion equation\n\nformulated by Weickert. With a 2x2 coefficient matrix G that depends on the gray values in Image, this is an enhancement of the mean curvature flow or intrinsic heat equation\non the gray value function u defined by the input image Image at a time . The smoothing operator mean_curvature_flow is a direct application of the mean curvature flow equation. With the operator inpainting_mcf, it can also be used for image inpainting. The discrete diffusion equation is solved in Iterations time steps of length Theta, so that the output image InpaintedImage contains the gray value function at the time Iterations * Theta .\n\nTo detect the image direction more robustly, in particular on noisy input data, an additional isotropic smoothing step can precede the computation of the gray value gradients. The parameter Sigma determines the magnitude of the smoothing by means of the standard deviation of a corresponding Gaussian convolution kernel, as used in the operator isotropic_diffusion for isotropic image smoothing.\n\nSimilar to the operator inpainting_mcf, the structure of the image data in Region is simplified by smoothing the level lines of Image. By this, image errors and unwanted objects can be removed from the image, while the edges in the neighborhood are extended continuously. This procedure is called image inpainting. The objective is to introduce a minimum amount of artefacts or smoothing effects, so that the image manipulation is least visible to a human beholder.\n\nWhile the matrix G is given by\n\nin the case of the operator inpainting_mcf, where I denotes the unit matrix, is again smoothed componentwise by a Gaussian filter of standard deviation Rho for coherence_enhancing_diff. Then, the final coefficient matrix\nis constructed from the eigenvalues and eigenvectors of the resulting intermediate matrix, where the functions\nwere determined empirically and taken from the publication of Weickert.\n\nHence, the diffusion direction in mean_curvature_flow is only determined by the local direction of the gray value gradient, while considers the macroscopic structure of the image objects on the scale Rho and the magnitude of the diffusion in coherence_enhancing_diff depends on how well this structure is defined.\n\nTo achieve the highest possible consistency of the newly created edges with the image data from the neighbourhood, the gray values are not mirrored at the border of Region to compute the convolution with the smoothing filter mask of scale Rho on the pixels close to the border, although this would be the common approach for filter operators. Instead, the existence of gray values on a band of width ceil(3.1*Rho)+2 pixels around Region is presumed and these values are used in the convolution. This means that Region must keep this much distance to the border of the image matrix Image. By involving the gray values and directional information from this extended area, it can be achieved that the continuation of the edges is not only continuous, but also smooth, which means without kinks. Please note that the inpainting progress is restricted to those pixels that are included in the ROI of the input image Image. If the ROI does not include the entire region Region, a band around the intersection of Region and the ROI is used to define the boundary values.\n\nTo decrease the number of iterations required for attaining a satisfactory result, it may be useful to initialize the gray value matrix in Region with the harmonic interpolant, a continuous function of minimal curvature, by applying the operator harmonic_interpolation to Image before calling inpainting_ced.\n\n## Parallelization\n\n• Multithreading type: reentrant (runs in parallel with non-exclusive operators).\n• Automatically parallelized on tuple level.\n\n## Parameters\n\nImage (input_object)  (multichannel-)image(-array) object (byte / uint2 / real)\n\nInput image.\n\nRegion (input_object)  region object\n\nInpainting region.\n\nInpaintedImage (output_object)  image(-array) object (byte / uint2 / real)\n\nOutput image.\n\nSigma (input_control)  real (real)\n\nSmoothing for derivative operator.\n\nDefault value: 0.5\n\nSuggested values: 0.0, 0.1, 0.5, 1.0\n\nRestriction: Sigma >= 0\n\nRho (input_control)  real (real)\n\nSmoothing for diffusion coefficients.\n\nDefault value: 3.0\n\nSuggested values: 0.0, 1.0, 3.0, 5.0, 10.0, 30.0\n\nRestriction: Rho >= 0\n\nTheta (input_control)  real (real)\n\nTime step.\n\nDefault value: 0.5\n\nSuggested values: 0.1, 0.2, 0.3, 0.4, 0.5\n\nRestriction: 0 < Theta <= 0.5\n\nIterations (input_control)  integer (integer)\n\nNumber of iterations.\n\nDefault value: 10\n\nSuggested values: 1, 5, 10, 20, 50, 100, 500\n\nRestriction: Iterations >= 1\n\n## Example (HDevelop)\n\n```read_image (Image, 'fabrik')\ngen_rectangle1 (Rectangle, 270, 180, 320, 230)\nharmonic_interpolation (Image, Rectangle, InpaintedImage, 0.01)\ninpainting_ced (InpaintedImage, Rectangle, InpaintedImage2, \\\n0.5, 3.0, 0.5, 1000)\ndev_display(InpaintedImage2)\n```\n\n## References\n\nJ. Weickert, V. Hlavac, R. Sara; “Multiscale texture enhancement”; Computer analysis of images and patterns, Lecture Notes in Computer Science, Vol. 970, pp. 230-237; Springer, Berlin; 1995.\nJ. Weickert, B. ter Haar Romeny, L. Florack, J. Koenderink, M. Viergever; “A review of nonlinear diffusion filtering”; Scale-Space Theory in Computer Vision, Lecture Notes in Comp. Science, Vol. 1252, pp. 3-28; Springer, Berlin; 1997.\n\n## Module\n\nFoundation\n\n Operators" ]

[ null ]

[ "Required field\nRequired field\nRequired field\n\n# Linear Elastic Materials\n\nA linear elastic material is a mathematical model used to analyze the deformation of solid bodies. It is useful to compute the relation between the forces applied on the object and the corresponding change in shape. In other terms, it relates the stresses and the strains in the material.\n\nFor a deformation process to be considered linear and elastic, the following conditions must be met:\n\n• The deformations, in terms of the material strains, are small.\n• When the loads are removed, the material naturally returns to its original, undeformed shape. In other words, the material stress level doesn’t reach the yield strength limit.\n• The magnitude of the deformations are proportional to the applied loads.\n\nA linear elastic material can be seen as the generalization of Hooke’s law for a spring:\n\n$$F = Ku \\tag{1}$$\n\nwhere:\n\n• $$F$$ is the tensile force applied to the spring,\n• $$u$$ is the resulting elongation of the spring, and\n• $$K$$ is the stiffness constant, a property of the spring dictated by the material and geometry.\n\nIn order to get rid of the geometry dependency of the stiffness, for the sake of generalization, the relation between force and deformation is expressed in terms of stress and strain:\n\n$$\\sigma = \\frac{F}{A} \\tag{2}$$\n\n$$\\varepsilon = \\frac{u}{L} \\tag{3}$$\n\nwhere:\n\n• $$\\sigma$$ is the normal stress on the prismatic object under tensile load: force per unit area,\n• $$\\varepsilon$$ is the strain in the material: deformation per unit length,\n• $$A$$ is the constant cross-section area of the object, perpendicular to the load, and\n• $$L$$ is the length of the object in the direction of the load and deformation.\n\nBy using these terms, the one-dimensional linear elastic relation can be expressed as:\n\n$$\\sigma = E \\varepsilon \\tag{4}$$\n\nwhere $$E$$ is the Young’s modulus of the material, the proportional relation between stress and strain:\n\n## Linear Elastic Materials in Three Dimensions\n\nIn the general case of a solid object subject to loads in multiple directions in space, the one-dimensional relation presented above is no longer sufficient to describe the deformations. In three dimensions, stress and strain are expressed as tensor quantities:\n\n$$\\sigma = \\begin{bmatrix} \\sigma_{xx} & \\tau_{xy} & \\tau_{xz} \\\\ \\tau_{yx} & \\sigma_{yy} & \\tau_{yz} \\\\ \\tau_{zx}& \\tau_{zy} & \\sigma_{zz} \\end{bmatrix} \\tag{5}$$\n\n$$\\varepsilon = \\begin{bmatrix} \\varepsilon_{xx} & \\frac{1}{2}\\gamma_{xy} & \\frac{1}{2}\\gamma_{xy} \\\\ \\frac{1}{2}\\gamma_{yx} & \\varepsilon_{yy} & \\frac{1}{2}\\gamma_{yz} \\\\ \\frac{1}{2}\\gamma_{zx} & \\frac{1}{2}\\gamma_{zy} & \\varepsilon_{yy} \\end{bmatrix} = \\frac{1}{2}(\\nabla_X u + \\nabla_X u^T) \\tag{6}$$\n\nWhere $$\\nabla_X$$ is the gradient operator computed in the undeformed configuration and $$u$$ is the vector of deformations in the material:\n\n$$u = \\begin{bmatrix} u_x \\\\ u_y \\\\ u_z \\end{bmatrix} \\tag{7}$$\n\nThe general form of the stress-strain relation can be written as:\n\n$$\\sigma = \\frac{E}{1+\\nu} \\Big( \\varepsilon + \\frac{\\nu}{1 – 2\\nu} Tr(\\varepsilon) I \\Big) \\tag{8}$$\n\nOr solved for the strain:\n\n$$\\varepsilon = \\frac{1 + \\nu}{E} \\Big( \\sigma – \\frac{\\nu}{1 + \\nu} Tr(\\sigma) I \\Big) \\tag{9}$$\n\nwhere $$\\nu$$ is the Poisson’s ratio, which relates normal stresses with deformations in the perpendicular directions. Here, it is assumed that the material is isotropic and homogeneous, which means that the material properties such as $$E$$ and $$\\nu$$ are constants with respect to position and orientation.\n\n## Workbench Setup\n\nFor the application of a linear elastic material in a structural simulation, the following set of parameters must be specified:\n\nIn the Workbench, go to Materials, confirm the Material behavior to Linear Elastic, set the successive parameters and assign them to a volume:", null, "Figure 2: Material parameters window for a linear elastic model being set up for a structural simulation in SimScale\n\nBeyond Linear Elastic Materials\n\nFor most of the structural analysis involving metals such as steel and aluminum, if the stresses are below yield strength, linear elastic material model shall be used. However, this model is incapable of truly describing the material behaviour, if the objective of the analysis is to study plasticity. In that case, use Elasto-plastic material model for the analysis. Additionally, there are also materials such as rubbers and elastomers for which the relationship between stress and strain is nonlinear while deforming elastically. For such materials, Hyperelastic material model is the most appropriate choice.\n\nTutorial: Stress Analysis of a Crane\n\nValidation Case: Design Analysis of a Spherical Pressure Vessel\n\nLast updated: May 26th, 2021" ]

[ null, "https://clqtg10snjb14i85u49wifbv-wpengine.netdna-ssl.com/wp-content/uploads/2020/10/image-7.png", null ]

[ "# QuantConnect: Plotting Our First Script\n\nIn this post, we are going to build on the RSI script we created back in the first tutorial. Those of you who followed that post will have noted that plotting was ignored. This is because the focus was to produce a minimal, viable, working algorithm. Now we have the basics out of the way, we can start to look at fleshing the script out and adding parts which are not absolutely required but often very helpful. Plotting is one of those items. Although our algorithms never need to look at a plot or a chart in order to make a decision, plotting is often very useful for the creator. This is to not only verify the algorithm is behaving as expected but also help us identify areas for improvement. Just looking at log files does not allow us to use one of our brains most advanced features, pattern recognition!\n\n### Tutorial Scope\n\nBy the end of this tutorial, we will aim to have fully plotted RSI and Volume Bar indicators. As we progress through it, we should cover the following topcis:\n• One line plotting of an indicator with `self.PlotIndicator()`\n• Plotting Data with `self.Plot()`\n• Creating a new custom chart\n• Adding a series to the chart\n• A brief look at `SeriesType` and `ChartType`\n• Adding our custom chart to an algorithm\n• Plotting limits\n\n### Plotting Concepts\n\nBefore we dive into the code, it is worth discussing a little background and some general plotting concepts to give context to the code. Plotting is something which varies a great deal between platforms. For example, in Backtrader all indicators are automatically plotted when added. In fact, if you don’t want to plot them, you need to manually turn them off. In Pine Script, you can just call a `plot()`function and plot pretty much anything you like at any time. QuantConnect takes a bit of a hybrid approach. Only our Equity, Benchmark and Stock plots are available and plotted by default. Everything else you should plot yourself. Plotting in QuantConnect can be as straightforward as calling a `self.Plot()` function during `OnData()`. However, if we want more customization options, users can dive deeper and create custom charts in a way which shares some similarity with creating a plot in `matplotlib`(a popular Python module for charting). At each stage of the creation process, we can specify options to really customize the chart to our preference. So summary, QuantConnect provides a nice level of flexibility. You can keep things simple if you need to but the tools are there for those willing to pay a slightly increased cost on the learning curve.\n\n## Let’s Begin\n\nThe code in this tutorial will be built over a few examples. This will allow us to progress from the most basic plotting through to creating a custom plot.\n\n### PlotIndicator()\n\nFirst we will start with `PlotIndicator()` method (function), a simple relevant helper method that that does exactly what it says on the tin. Furthermore, we can use this in the `Initialize`method. This means once we add the plot, we do not need to update it when new data arrives. It is automatically updated for us.\n```### <summary>\n### Simple RSI Strategy intended to provide a minimal algorithm example using\n### one indicator with the most basic plotting\n### </summary>\nclass RSIAlgorithm(QCAlgorithm):\n\ndef Initialize(self):\n'''Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.'''\n\n# Set our main strategy parameters\nself.SetStartDate(2016,1, 1) # Set Start Date\nself.SetEndDate(2017,1,1) # Set End Date\nself.SetCash(10000) # Set Strategy Cash\n\nRSI_Period = 14 # RSI Look back period\nself.RSI_OB = 60 # RSI Overbought level\nself.RSI_OS = 40 # RSI Oversold level\nself.Allocate = 0.25 # Percentage of captital to allocate\n\n# Find more symbols here: http://quantconnect.com/data\n\nself.RSI_Ind = self.RSI(\"AAPL\", RSI_Period)\n\n# Ensure that the Indicator has enough data before trading,.\nself.SetWarmUp(RSI_Period)\n\n# Plot the RSI\nself.PlotIndicator(\"RSI\", self.RSI_Ind)\n\ndef OnData(self, data):\n'''OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.\n\nArguments:\ndata: Slice object keyed by symbol containing the stock data\n'''\n# Check if we are in the market\nif not self.Portfolio.Invested:\n# If not, we check the RSI Indicator\nif self.RSI_Ind.Current.Value < self.RSI_OS:\nself.SetHoldings(\"AAPL\", self.Allocate)\nelse:\nif self.RSI_Ind.Current.Value > self.RSI_OB:\n# Sell Apple\nself.Liquidate(\"AAPL\")```\n\n#### Mini Commentary\n\nThose just graduating from our first script tutorial might be hard pressed to see the difference with our first script. We are simply adding one extra line to our `Initialize()`method. `self.PlotIndicator(\"RSI\", self.RSI_Ind)` This creates a new plot called RSI and will plot whatever value is reported by `self.RSI_Ind.Current.Value`. Nice and simple!\n\n#### Running the Algorithm\n\nLet’s run the algorithm and take a look at what we have created. As soon as the backtest is finished, you should see something that looks like this:", null, "I know what you might be thinking…\n\n#### Where is my Plot?\n\nQuantConnect does not show you any stacked plots by default (stacked means appears under the main chart). As such, you need to select the RSI chart from the right-hand side of the results.", null, "Once you do that, you will see the RSI chart is inserted underneath the equity chart.", null, "#### Benchmark and Stockplot\n\nAt this point, you may have also noticed the extra “Benchmark” and “Stock Plot” options. The benchmark plot provides an alternative “straight line” benchmark in addition to the S&P500 benchmark which appears on the equity curve. Press it and you will see it appear underneath the RSI chart (assuming you still have it selected). Stockplot is more interesting. Click on the down arrow and you will be able to select AAPL from the list. Only AAPL appears here because it is the only equity we added in the script. Selecting this plot will show you the close prices for AAPL and additionally buy/sell markers. Excellent for gauging whether you are buying/selling at good moments. That is not always easy to decipher from the equity chart.\n\n### Plot()\n\nThe next plotting method (function) we will take a look at is `self.Plot()`. This can be used in a simple form when `OnData()` is called (executed) or it can be used to update a custom chart that we have previously created ourselves. We will look at the former, simple method first before moving onto the latter in our final example. Let’s add some useful `Volume`information to our strategy. We will do this using the simple plot method first. After doing this, we will also see very quickly that it can be improved a lot by creating a custom chart!\n```### <summary>\n### Simple RSI Strategy intended to provide a minimal algorithm example using\n### one indicator with the most basic plotting\n### </summary>\nclass RSIAlgorithm(QCAlgorithm):\n\ndef Initialize(self):\n'''Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.'''\n\n# Set our main strategy parameters\nself.SetStartDate(2016,1, 1) # Set Start Date\nself.SetEndDate(2017,1,1) # Set End Date\nself.SetCash(10000) # Set Strategy Cash\n\nRSI_Period = 14 # RSI Look back period\nself.RSI_OB = 60 # RSI Overbought level\nself.RSI_OS = 40 # RSI Oversold level\nself.Allocate = 0.25 # Percentage of captital to allocate\n\n# Find more symbols here: http://quantconnect.com/data\n\nself.RSI_Ind = self.RSI(\"AAPL\", RSI_Period)\n\n# Ensure that the Indicator has enough data before trading,.\nself.SetWarmUp(RSI_Period)\n\n# Plot the RSI\nself.PlotIndicator(\"RSI\", self.RSI_Ind)\n\ndef OnData(self, data):\n'''OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.\n\nArguments:\ndata: Slice object keyed by symbol containing the stock data\n'''\n\nself.Plot('Volume', data[\"AAPL\"].Volume)\n\n# Check if we are in the market\nif not self.Portfolio.Invested:\n# If not, we check the RSI Indicator\nif self.RSI_Ind.Current.Value < self.RSI_OS:\nself.SetHoldings(\"AAPL\", self.Allocate)\nelse:\nif self.RSI_Ind.Current.Value > self.RSI_OB:\n# Sell Apple\nself.Liquidate(\"AAPL\")```\n\n#### Mini Commentary\n\nIn the second example, we have simply added the following line to the `On_Data()`method (function). `self.Plot('Volume', data[\"AAPL\"].Volume)` This will plot the `Volume`values every time `On_Data()`is called (In our case, `On_Data()`is called every time we receive a new daily bar). The first argument `'Volume'` controls the name of the chart that will be updated. In this case it is a chart called `Volume`….. Wait a minute….. what volume chart? We have not added a volume chart yet! Well, it will actually be created behind the scenes using the name you provide (In this case `'Volume'`). As such, for this example, you can put any text you like in that argument. If we had created a custom chart (which we will do soon) you could target plotting on that specific chart by giving it the custom charts name.\n\n#### Running Example 2\n\nAfter running the backtest you should have an equity chart that looks like this:", null, "As you can see, the plot is overlayed on the Equity chart. Furthermore, because `Volume` values are so much larger than the equity values, the equity bars are obscured. This is because they are sharing the same chart and the same scale/index. So we can see that when we use `self.Plot()`without setting up a custom chart first, it plots the values you feed it with a set of default values. In this case, one of the default values is to overlay the line on the main equity chart. Due to this, calling `self.Plot()` without setting up a custom chart first is probably best reserved for occasions when you want a quick and dirty debug plot or for values which share a similar scale to your account equity.\n\n## Creating a Custom Chart\n\nIn our final example, we will move onto creating a custom chart and look at some of the options which are available to us when doing so.\n```### <summary>\n### Simple RSI Strategy intended to provide a minimal algorithm example using\n### one indicator with the most basic plotting\n### </summary>\n\nclass RSIAlgorithm(QCAlgorithm):\n\ndef Initialize(self):\n'''Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.'''\n\n# Set our main strategy parameters\nself.SetStartDate(2016,1, 1) # Set Start Date\nself.SetEndDate(2017,1,1) # Set End Date\nself.SetCash(10000) # Set Strategy Cash\n\nRSI_Period = 14 # RSI Look back period\nself.RSI_OB = 60 # RSI Overbought level\nself.RSI_OS = 40 # RSI Oversold level\nself.Allocate = 0.25 # Percentage of captital to allocate\n\n# Find more symbols here: http://quantconnect.com/data\n\nself.RSI_Ind = self.RSI(\"AAPL\", RSI_Period)\n\n# Ensure that the Indicator has enough data before trading,.\nself.SetWarmUp(RSI_Period)\n\n# Plot the RSI\nself.PlotIndicator(\"RSI\", self.RSI_Ind)\n\n# Create a custom volume chart\nVolChart = Chart(\"Volume\", ChartType.Stacked)\n\ndef OnData(self, data):\n'''OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.\n\nArguments:\ndata: Slice object keyed by symbol containing the stock data\n'''\nif data[\"AAPL\"].Close >= data[\"AAPL\"].Open:\nelse:\nself.Plot('Volume', 'Selling Volume', data[\"AAPL\"].Volume)\n\n# Check if we are in the market\nif not self.Portfolio.Invested:\n# If not, we check the RSI Indicator\nif self.RSI_Ind.Current.Value < self.RSI_OS:\nself.SetHoldings(\"AAPL\", self.Allocate)\nelse:\nif self.RSI_Ind.Current.Value > self.RSI_OB:\n# Sell Apple\nself.Liquidate(\"AAPL\")```\n\n### Commentary\n\nThe code to configure the chart appears in our  `Initialize`method. It is here that we create our chart and customize it to our taste. So let’s take s look at our new code and discuss some of the customization options available. To start we create a new chart with: `VolChart = Chart(\"Volume\", ChartType.Stacked)` It is here we specify our`ChartType` and we have the following options available to us:\n• `Chart.Stacked`: Used in our example. This means the chart will appear as a separate chart below the main equity chart.\n• `Chart.Overlay`: This means that the chart will be overlayed on top of the main equity chart.\nNext, we add some data series to the chart. I.e things we want to plot. Since we are interested in volume, we will create two series. One for “buying volume” and one for “selling volume”. Buying volume just means that the candle/bar closed up (green) and so it signifies that the volume seen during that period saw more units bought than sold (else how would the price close up?). Conversely, “selling volume” is the opposite. A `Series` can be displayed in many different ways and as such QuantConnect provides quite a few types. We can specify Line, Scatter, Candle, Bar, Flag, StackedArea and Pie `SeriesType`options. In our example, we use `SeriesType.Bar`as this is the industry standard way of displaying volume information. Finally, we add the chart to our algorithm with `self.AddChart()`. If we don’t do this, when we try to plot our volume values during `OnData()`, the chart won’t exist in the Algorithm. As such, Quanconnect will just create a new plot using the default settings like we say in example 2.\n\n#### On Data\n\nOk, so now we have our chart setup and ready, we now just need to populate it! Because we created two series (buying and selling volume), we can’t just blindly add volume to both of them. Instead, we must first make a little check to see what type of volume we have and then plot to the correct series. This is exactly what we do with the following lines:\n``` if data[\"AAPL\"].Close >= data[\"AAPL\"].Open:\nelse:\nself.Plot('Volume', 'Selling Volume', data[\"AAPL\"].Volume)```\nSome readers might take exception to the `>=`condition on the first line. After all, if the `Close`is equal to the `Open`then we do not really have buying volume. If you fall into that category, you can just add a third series to the chart.\n\n#### Running Example 3\n\nOnce we run the script you should have a volume chart that look like this:", null, "## Plotting Limits\n\nBefore we finish, we should point out that QuantConnect limits the number of points which can be charted on any given plot. The assumption is that this is limited for resource reasons. Afterall, they have vast amounts of tick data available and plotting tick data over a long period of time has got to be a recipe for system strain. Go ahead and change the line `self.AddEquity(\"AAPL\", Resolution.Daily)`to`self.AddEquity(\"AAPL\", Resolution.Minute)`. Now run the script once again, you should notice a warning in the terminal that looks like this:", null, "Also if you look at your RSI plot, you will see that it stops plotting once the plotting limit is reached.", null, "As such it makes sense to select specific date ranges when you want to use plotting to verify the algorithm is performing as expected or generate new ideas.\n\n## Find This Post Useful?\n\nIf this post saved you time and effort, please consider donating a coffee to support the site!\n\nDontate with PayPal using any payment method you are comfortable with.", null, "", null, "3PUY12Tgp8xynrMCbBdLE56DShzCbxFG8i", null, "0x9c32a2e1e4a06b0995777ac86745c0db1c13bdfc", null, "LUph5xfqvn2bNfthhEcw9QiVLBYeztacFR" ]

[ null, "https://backtest-rookies.com/wp-content/uploads/2018/08/RSI-Plotting-PlotIndicator-Results.png", null, "https://backtest-rookies.com/wp-content/uploads/2018/08/RSI-Plotting-PlotIndicator-Results-Marked-Up.png", null, "https://backtest-rookies.com/wp-content/uploads/2018/08/RSI-Plotting-PlotIndicator-RSI-Plot.png", null, "https://backtest-rookies.com/wp-content/uploads/2018/08/RSI-Plotting-Plot-Volume.png", null, "https://backtest-rookies.com/wp-content/uploads/2018/08/Final-Volume-Chart.png", null, "https://backtest-rookies.com/wp-content/uploads/2018/08/RSI-Plotting-Plotting-Limit-Exceeded-Terminal.png", null, "https://backtest-rookies.com/wp-content/uploads/2018/08/RSI-Plotting-Plotting-Limit-Exceeded-RSI-Chart.png", null, "https://www.paypalobjects.com/en_GB/i/scr/pixel.gif", null, "https://backtest-rookies.com/wp-content/uploads/2018/07/My-BTC-Address.png", null, "https://backtest-rookies.com/wp-content/uploads/2018/07/My-ETH-Address.png", null, "https://backtest-rookies.com/wp-content/uploads/2018/07/My-LTC-Address.png", null ]

[ "Related Articles\nbits.Reverse16() Function in Golang with Examples\n• Last Updated : 19 Apr, 2020\n\nGo language provides inbuilt support for bits to implement bit counting and manipulation functions for the predeclared unsigned integer types with the help of bits package. This package provides Reverse16() function which is used to find the reversed order of the value of a. To access Reverse16() function you need to add a math/bits package in your program with the help of the import keyword.\n\nSyntax:\n\n`func Reverse16(a uint16) uint16`\n\nParameters: This function takes one parameter of uint16 type, i.e., a.\n\nReturn Value: This function returns the value of a with its bits in reversed order.\n\nExample 1 :\n\n `// Golang program to illustrate bits.Reverse16() Function``package main`` ` `import (``    ``\"fmt\"``    ``\"math/bits\"``)`` ` `// Main function``func main() {`` ` `    ``// Using Reverse16() function``    ``a := bits.Reverse16(5)``    ``fmt.Printf(``\"Reverse order of %d: %b\"``, 5, a)`` ` `}`\n\nOutput:\n\n`Reverse order of 5: 1010000000000000`\n\nExample 2 :\n\n `// Golang program to illustrate bits.Reverse16() Function``package main`` ` `import (``    ``\"fmt\"``    ``\"math/bits\"``)`` ` `// Main function``func main() {`` ` `    ``// Using Reverse16() function``    ``a1 := bits.Reverse16(9)``    ``fmt.Printf(``\"Reverse16(%016b) := %b\\n\"``, 9, a1)`` ` `    ``a2 := bits.Reverse16(13)``    ``fmt.Printf(``\"Reverse16(%016b) := %b\\n\"``, 13, a2)`` ` `}`\n\nOutput:\n\n```Reverse16(0000000000001001) := 1001000000000000\nReverse16(0000000000001101) := 1011000000000000\n```\n\nAttention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.\n\nMy Personal Notes arrow_drop_up" ]

[ null ]

[ "# mat 271 optimzation project.docx - Daniel 1 Eric Daniel...\n\n• Essay\n• 10\n• 100% (6) 6 out of 6 people found this document helpful\n\nThis preview shows page 1 - 3 out of 10 pages.\n\nDaniel 1 Eric Daniel March 22, 2018 Mat -271-4130 Optimization Project Introduction: This is a report about the optimization of two cans. A Campbells soup can, and a Bush’s beans can. In this report you see how each can is optimized and which can is best optimized. Can #1: Campbells Cream of Mushroom soup Part 1 -find max volume The radius of this can was found to be 3.5810 cm with a height of 10.5 cm. The computed volume was found to be 423.0073 cm^3 and the computed surface area was found to be 316.8237 cm^2. After taking the surface area equation and putting it in terms of h (h= (316.8237- 2 πr 2 ¿ / 2 πr ¿ / ¿ I was able to take that equation and put into my volume equation V=158.4419- πr 3 and using the first derivate test. I was able to find a maximum new radius for the can which was found to be 4.099a cm and taking that and plugging it in to my surface area equation I found the maximum height to be 8.1994 cm. Using that these to new values I was able to compute that the can’s maximum volume is 432.9695 cm^3. This means the can was 97.9771% optimized. I believe Campbell’s kept optimization in mind when they produced there can. See below are the calculations and a graph of volume vs. radius (The grey dot is the max and the color is the current volume). There will be some error in these calculations because I had to round the numbers.\nDaniel 2 Calculations Graph\n•", null, "•", null, "•", null, "" ]

[ null, "https://www.coursehero.com/assets/img/doc-landing/start-quote.svg", null, "https://www.coursehero.com/assets/img/doc-landing/start-quote.svg", null, "https://www.coursehero.com/assets/img/doc-landing/start-quote.svg", null ]

[ "Search a number\nBaseRepresentation\nbin101101100001010100110110…\n…010100110101111110010111\n3222020212010221002000010212211\n4231201110312110311332113\n5202220103122313031241\n61545443344152454251\n760112063460055622\noct5541246624657627\n9866763832003784\n10200202222002071\n11588773160715a3\n121a5546470aa387\n138792cb0a44183\n143761ba6c6cdb9\n151822abc629781\nhexb61536535f97\n\n200202222002071 has 2 divisors, whose sum is σ = 200202222002072. Its totient is φ = 200202222002070.\n\nThe previous prime is 200202222002059. The next prime is 200202222002093. The reversal of 200202222002071 is 170200222202002.\n\nIt is an a-pointer prime, because the next prime (200202222002093) can be obtained adding 200202222002071 to its sum of digits (22).\n\nIt is a weak prime.\n\nIt is a cyclic number.\n\nIt is not a de Polignac number, because 200202222002071 - 25 = 200202222002039 is a prime.\n\nIt is a congruent number.\n\nIt is not a weakly prime, because it can be changed into another prime (200202222002021) by changing a digit.\n\nIt is a polite number, since it can be written as a sum of consecutive naturals, namely, 100101111001035 + 100101111001036.\n\nIt is an arithmetic number, because the mean of its divisors is an integer number (100101111001036).\n\nAlmost surely, 2200202222002071 is an apocalyptic number.\n\n200202222002071 is a deficient number, since it is larger than the sum of its proper divisors (1).\n\n200202222002071 is an equidigital number, since it uses as much as digits as its factorization.\n\n200202222002071 is an odious number, because the sum of its binary digits is odd.\n\nThe product of its (nonzero) digits is 896, while the sum is 22.\n\nAdding to 200202222002071 its reverse (170200222202002), we get a palindrome (370402444204073).\n\nThe spelling of 200202222002071 in words is \"two hundred trillion, two hundred two billion, two hundred twenty-two million, two thousand, seventy-one\"." ]

[ null ]

[ "", null, "This week's book giveaway is in the General Computing forum.We're giving away four copies of Emmy in the Key of Code and have Aimee Lucido on-line!See this thread for details.", null, "Win a copy of Emmy in the Key of Code this week in the General Computing forum!\nprogramming forums Java Mobile Certification Databases Caching Books Engineering Micro Controllers OS Languages Paradigms IDEs Build Tools Frameworks Application Servers Open Source This Site Careers Other all forums\nthis forum made possible by our volunteer staff, including ...\nMarshals:\n• Campbell Ritchie\n• Liutauras Vilda\n• Junilu Lacar\n• Jeanne Boyarsky\n• Bear Bibeault\nSheriffs:\n• Knute Snortum\n• Devaka Cooray\n• Tim Cooke\nSaloon Keepers:\n• Tim Moores\n• Stephan van Hulst\n• Tim Holloway\n• Ron McLeod\n• Carey Brown\nBartenders:\n• Paweł Baczyński\n• Piet Souris\n• Vijitha Kumara\n\n# Graphs and identifying adjacent nodes\n\nGreenhorn\nPosts: 1\n•", null, "•", null, "•", null, "•", null, "Hi\nI have an applet which has a graph that has a central node (root) from this comes 5 child nodes which also act as parents to 5 more child nodes (leafs) each. Initially I want only the root node and its immediate children visible (those attached direct to the root node). If one of these children is clicked then I want only the nodes directly connected to the clicked node (its children and the root node) to be viewable, but all other nodes to be invisible (change color to same as background). The best way I see to do this is the determine which nodes are within one edge (vertice) of the clicked node and make them visible while all other nodes (either two or more edges away from clicked node) become the same color as the background and therefore invisible. Does anyone know how to measure how many edges one node is from another node to do this. I have included my java and html code so far below.\nThanks\n\n********************* JAVA *************************\n\nimport java.util.*;\nimport java.awt.*;\nimport java.applet.*;\nimport java.awt.event.*;\n\n//create the class 'Node' and its variables x,y,dx,dy,fixed and lbl\n\nclass Node{\ndouble x;\ndouble y;\n\ndouble dx;\ndouble dy;\n\nboolean fixed;\nboolean hide;\n\nString lbl;\n\nString color;\n}\n\n//create class 'Edge' and declare its variables from, to and len\n\nclass Edge {\nint from;\nint to;\n\ndouble len;\n}\n\n//create the class 'GraphPanel' which is a subclass of the superclass Panel//creates an interface to runnable, mouselistener etc//creates variables, arrays and calls relaxer thread?\n\nclass GraphPanel extends Panel\nimplements Runnable, MouseListener, MouseMotionListener {\nGraph graph;\n\n//creates an integer variable call nnodes (holds total number of nodes)\nint nnodes;\n\n//creates an array of 100 node objects called 'nodes'\nNode nodes[] = new Node;\n\n//creates an integer variable call nnodes (holds total number of nodes)\nint nedges;\n\n//creates an array of 200 edge objects called 'edges'\nEdge edges[] = new Edge;\n\n//sets mouse listener to the grap\n\nGraphPanel(Graph graph) {\nthis.graph = graph;\n}\n//finds node by searching for them by name (lbl)\nint findNode(String lbl) {\n//scans array of nodes and returns index number or match\nfor (int i = 0 ; i < nnodes ; i++) {\nif (nodes[i].lbl.equals(lbl)) {\nreturn i;\n}\n}\n//calls addNode function using lbl arguement\n}\nNode n = new Node();\n//n.setColor(java.awt.Color.blue);\n//Color(0, 0, 0);\nn.x = 10 + 380*Math.random();\nn.y = 10 + 380*Math.random();\nn.lbl = lbl;\n//n.hide = true;\nnodes[nnodes] = n;\nreturn nnodes++;\n}\nvoid addEdge(String from, String to, int len) {\n//new edge of type Edge\nEdge e = new Edge();\n//use findnode method to locate endpoints by node name give in arguements\ne.from = findNode(from);\ne.to = findNode(to);\ne.len = len;\nedges[nedges++] = e;\n}\n\npublic void run() {\nwhile (relaxer == me) {\nrelax();\n//if (random && (Math.random() < 0.03)) {\nif (Math.random() < 0.03) {\nNode n = nodes[(int)(Math.random() * nnodes)];\nif (!n.fixed) {\nn.x += 100*Math.random() - 50;\nn.y += 100*Math.random() - 50;\n}\n}\ntry {\n} catch (InterruptedException e) {\nbreak;\n}\n}\n}\n\nsynchronized void relax() {\nfor (int i = 0 ; i < nedges ; i++) {\nEdge e = edges[i];\ndouble vx = nodes[e.to].x - nodes[e.from].x;\ndouble vy = nodes[e.to].y - nodes[e.from].y;\ndouble len = Math.sqrt(vx * vx + vy * vy);\nlen = (len == 0) ? .0001 : len;\ndouble f = (edges[i].len - len) / (len * 3);\ndouble dx = f * vx;\ndouble dy = f * vy;\n\nnodes[e.to].dx += dx;\nnodes[e.to].dy += dy;\nnodes[e.from].dx += -dx;\nnodes[e.from].dy += -dy;\n}\n\nfor (int i = 0 ; i < nnodes ; i++) {\nNode n1 = nodes[i];\ndouble dx = 0;\ndouble dy = 0;\n\nfor (int j = 0 ; j < nnodes ; j++) {\nif (i == j) {\ncontinue;\n}\nNode n2 = nodes[j];\ndouble vx = n1.x - n2.x;\ndouble vy = n1.y - n2.y;\ndouble len = vx * vx + vy * vy;\nif (len == 0) {\ndx += Math.random();\ndy += Math.random();\n} else if (len < 100*100) {\ndx += vx / len;\ndy += vy / len;\n}\n}\ndouble dlen = dx * dx + dy * dy;\nif (dlen > 0) {\ndlen = Math.sqrt(dlen) / 2;\nn1.dx += dx / dlen;\nn1.dy += dy / dlen;\n}\n}\n\nDimension d = getSize();\nfor (int i = 0 ; i < nnodes ; i++) {\nNode n = nodes[i];\nif (!n.fixed) {\nn.x += Math.max(-5, Math.min(5, n.dx));\nn.y += Math.max(-5, Math.min(5, n.dy));\n}\nif (n.x < 0) {\nn.x = 0;\n} else if (n.x > d.width) {\nn.x = d.width;\n}\nif (n.y < 0) {\nn.y = 0;\n} else if (n.y > d.height) {\nn.y = d.height;\n}\nn.dx /= 2;\nn.dy /= 2;\n}\nrepaint();\n}\n\nNode pick;\nboolean pickfixed;\nImage offscreen;\nDimension offscreensize;\nGraphics offgraphics;\n\n//fixedcolor sets color of central node\nfinal Color fixedColor = Color.white;\n//color of node when clicked\nfinal Color selectColor = Color.blue;\nfinal Color edgeColor = Color.gray;\n//set color of node fill\nfinal Color nodeColor = Color.yellow;\n//final Color nodeColor = new Color(250, 220, 100); -----this line was replaced by the lien above\n//new color type created to hide nodes on red background\nfinal Color hideColor = Color.red;\n//sets the colors of edges (edges change colors as they move around) - next 3 lines\nfinal Color arcColor1 = Color.yellow;\nfinal Color arcColor2 = Color.green;\nfinal Color arcColor3 = Color.black;\n\n//paintnode method gives color and appearance to each nodes\npublic void paintNodeorg(Graphics g, Node n, FontMetrics fm) {\nint x = (int)n.x;\nint y = (int)n.y;\n//sets color for rectangle fill dependent on whether node is fixed or not\ng.setColor((n == pick) ? selectColor : (n.fixed ? fixedColor : (n.hide ? hideColor : nodeColor)));\n//g.setColor((n == pick) ? selectColor : (n.fixed ? fixedColor : nodeColor));-------this line was replaced by above\n//length of box of node\nint w = fm.stringWidth(n.lbl) + 10;\n//height of nodes\nint h = fm.getHeight() + 4;\n//location of rectangle fill - offset\ng.fillRect(x - w/2, y - h / 2, w, h);\n//changes color of text in nodes and node outline\ng.setColor(Color.red);\n//offset of text and rectangle fill\ng.drawRect(x - w/2, y - h / 2, w-1, h-1);\n//offset of text only\ng.drawString(n.lbl, x - (w-10)/2, (y - (h-4)/2) + fm.getAscent());\n}\n\npublic void paintNode(Graphics g, Node n, FontMetrics fm) {\nint x = (int)n.x;\nint y = (int)n.y;\n//sets color for rectangle fill dependent on whether node is fixed or not\ng.setColor(Color.green);\n//g.setColor((n == pick) ? selectColor : (n.fixed ? fixedColor : nodeColor));-------this line was replaced by above\n//length of box of node\nint w = fm.stringWidth(n.lbl) + 10;\n//height of nodes\nint h = fm.getHeight() + 4;\n//location of rectangle fill - offset\ng.fillRect(x - w/2, y - h / 2, w, h);\n//changes color of text in nodes and node outline\ng.setColor(Color.red);\n//offset of text and rectangle fill\ng.drawRect(x - w/2, y - h / 2, w-1, h-1);\n//offset of text only\ng.drawString(n.lbl, x - (w-10)/2, (y - (h-4)/2) + fm.getAscent());\n}\n\npublic synchronized void update(Graphics g) {\nDimension d = getSize();\nif ((offscreen == null) || (d.width != offscreensize.width) || (d.height != offscreensize.height)) {\noffscreen = createImage(d.width, d.height);\noffscreensize = d;\nif (offgraphics != null) {\noffgraphics.dispose();\n}\noffgraphics = offscreen.getGraphics();\noffgraphics.setFont(getFont());\n}\n\noffgraphics.setColor(getBackground());\noffgraphics.fillRect(0, 0, d.width, d.height);\nfor (int i = 0 ; i < nedges ; i++) {\nEdge e = edges[i];\nint x1 = (int)nodes[e.from].x;\nint y1 = (int)nodes[e.from].y;\nint x2 = (int)nodes[e.to].x;\nint y2 = (int)nodes[e.to].y;\nint len = (int)Math.abs(Math.sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2)) - e.len);\n//sets edge color dependent on length of edge at any point\noffgraphics.setColor((len < 10) ? arcColor1 : (len < 20 ? arcColor2 : arcColor3)) ;\noffgraphics.drawLine(x1, y1, x2, y2);\n}\n\nFontMetrics fm = offgraphics.getFontMetrics();\nfor (int i = 0 ; i < nnodes ; i++) {\npaintNode(offgraphics, nodes[i], fm);\n}\ng.drawImage(offscreen, 0, 0, null);\n}\n\n//1.1 event handling\npublic void mouseClicked(MouseEvent e) {\n}\n\npublic void mousePressed(MouseEvent e) {\ndouble bestdist = Double.MAX_VALUE;\nint x = e.getX();\nint y = e.getY();\nfor (int i = 0 ; i < nnodes ; i++) {\nNode n = nodes[i];\ndouble dist = (n.x - x) * (n.x - x) + (n.y - y) * (n.y - y);\nif (dist < bestdist) {\npick = n;\nbestdist = dist;\n}\n}\npickfixed = pick.fixed;\npick.fixed = true;\npick.x = x;\npick.y = y;\nrepaint();\ne.consume();\n}\n\npublic void mouseReleased(MouseEvent e) {\nremoveMouseMotionListener(this);\nif (pick != null) {\npick.x = e.getX();\npick.y = e.getY();\npick.fixed = pickfixed;\npick = null;\n}\nrepaint();\ne.consume();\n}\n\npublic void mouseEntered(MouseEvent e) {\n}\n\npublic void mouseExited(MouseEvent e) {\n}\n\npublic void mouseDragged(MouseEvent e) {\npick.x = e.getX();\npick.y = e.getY();\nrepaint();\ne.consume();\n}\n\npublic void mouseMoved(MouseEvent e) {\n}\n\npublic void start() {\nrelaxer.start();\n}\n\npublic void stop() {\nrelaxer = null;\n}\n\n}\n\npublic class Graph extends Applet implements ActionListener, ItemListener {\n\nGraphPanel panel;\nPanel controlPanel;\n\npublic void init() {\nsetLayout(new BorderLayout());\n\n//creates applet panel\npanel = new GraphPanel(this);\ncontrolPanel = new Panel();\nsetBackground(Color.red);\n\n//imports data from html params tags\nString edges = getParameter(\"edges\");\n\n// uses stringtokenizer to create token t by splitting edges param by , delimter and then testing of param still has more tokens to continue with\nfor (StringTokenizer t = new StringTokenizer(edges, \",\") ; t.hasMoreTokens() ; ) {\n//places value of next tohen into str eg str = The_World-Europe/90\nString str = t.nextToken();\n//places index number (location) of - into variable i (0=first index)\nint i = str.indexOf('-');\n//if - exists any except first postion\nif (i > 0) {\n//len = 50\nint len = 50;\n//places index number of / into variable j (0 = first index)\nint j = str.indexOf('/');\n//if / exists anywhere except first position (0)\nif (j > 0) {\n//len gets value given after / in params from webpage\nlen = Integer.valueOf(str.substring(j+1)).intValue();\n//str gets the value of the section of str between 0 and location of /\n//so therefore str = North_America-New York for example\nstr = str.substring(0, j);\n}\n//calls addedge (above) method from panel class with the arguements that\n//identify what element of string to use (String from, String to, int len)\n}\n}\n//get size of applet panel and put variable 'd'\nDimension d = getSize();\n//gets value of centre from html parameters\nString center = getParameter(\"center\");\nif (center != null){\nNode n = panel.nodes[panel.findNode(center)];\n//sets location of centre node as half width and half height of panel\nn.x = d.width / 2;\nn.y = d.height / 2;\nn.fixed = true;\n}\n}\n\npublic void destroy() {\nremove(panel);\nremove(controlPanel);\n}\n\npublic void start() {\npanel.start();\n\n}\n\npublic void stop() {\npanel.stop();\n}\n\npublic void actionPerformed(ActionEvent e) {\nObject src = e.getSource();\n}\n\npublic void itemStateChanged(ItemEvent e) {\nObject src = e.getSource();\nboolean on = e.getStateChange() == ItemEvent.SELECTED;\n}\n\n//collect data from html parameters and place into nested array info[][]\n\npublic String[][] getParameterInfo() {\nString[][] info = {\n//parameter name, kind of value, description\n{\"edges\", \"delimited string\", \"A comma-delimited list of all the edges. It takes the form of 'C-N1,C-N2,C-N3,C-NX,N1-N2/M12,N2-N3/M23,N3-NX/M3X,...' where C is the name of center node (see 'center' parameter) and NX is a node attached to the center node. For the edges connecting nodes to eachother (and not to the center node) you may (optionally) specify a length MXY separated from the edge name by a forward slash.\"},\n{\"center\", \"string\", \"The name of the center node.\"}\n};\nreturn info;\n}\n\n}\n\n**************END JAVA*******************\n\n**************HTML*********************\n<html>\n<title>The World</title>\n<body bgcolor=red>\n<object codebase=\".\" code=\"Graph.class\" width=400 height=400>\n<param name=edges value=\"The_World-Europe/90,\nEurope-Moscow/40,\nEurope-Paris/40,\nEurope-London/40,\nEurope-Rome/40,\nThe_World-Asia/90,\nAsia-New Delhi/40,\nAsia-Beijing/40,\nAsia-Jakarta/40,\nAsia-Manila/40,\nAsia-Hong Kong/40,\nAsia-Tokyo/40,\nThe_World-North_America/90,\nNorth_America-Los Angeles/40,\nNorth_America-Chicago/40,\nNorth_America-New York/40,\nNorth_America-San Francisco/40,\nNorth_America-Honolulu/40,\nNorth_America-Washington/40,\nThe_World-South_America/90,\nSouth_America-Lima/40,\nSouth_America-Santiago/40,\nSouth_America-Rio De Janeiro/40,\nThe_World-Africa/90,\nAfrica-Cairo/40,\nAfrica-Capetown/40,\nAfrica-Cape Town/40,\nThe_World-Australasia/90,\nAustralasia-Sydney/40,\nAustralasia-Melbourne/40,\nAustralasia-Perth/40,\nAustralasia-Auckland/40\">\n<param name=center value=\"The_World\">\nalt=\"Your browser probably doesn't understand the <OBJECT> tag so it isn't running the applet or perhaps you need a Java Plugin\"\nYour browser is completely ignoring the <OBJECT> tag!\n</object>\n<hr>\n</body>\n</html>\n\nRanch Hand\nPosts: 1535\n•", null, "•", null, "•", null, "•", null, "This will hide/show the child nodes of any parent node you select with a mousePress.\nI got tired of the browser/plug–in caching and set it up with a main method so I could run it from the prompt. You might consider changing the class names and running it as–is to see what it does.\n\n[ November 20, 2004: Message edited by: Craig Wood ]", null, "Won't you please? Please won't you be my neighbor? - Fred Rogers. Tiny ad: Java file APIs (DOC, XLS, PDF, and many more) https://products.aspose.com/total/java\n•", null, "" ]

[ null, "https://www.coderanch.com/mooseImages/betaview/moosefly.gif", null, "https://www.coderanch.com/templates/default/images/20x20_orange_asterisk.gif", null, "https://www.coderanch.com/templates/default/betaview/images/plus-1-thumb.gif", null, "https://www.coderanch.com/templates/default/images/pie/give-pie-button.png", null, "https://www.coderanch.com/templates/default/betaview/images/quote_button.gif", null, "https://www.coderanch.com/templates/default/betaview/images/report_post.png", null, "https://www.coderanch.com/templates/default/betaview/images/plus-1-thumb.gif", null, "https://www.coderanch.com/templates/default/images/pie/give-pie-button.png", null, "https://www.coderanch.com/templates/default/betaview/images/quote_button.gif", null, "https://www.coderanch.com/templates/default/betaview/images/report_post.png", null, "https://www.coderanch.com/images/bunkhouse_smoke.gif", null, "https://coderanch.com/t/342646/i/170/erry.jpg", null ]

[ "Maximum Sum of Cubic Products\n\nAlgebra Level 5\n\nLet $x, y, z$ be non-negative real numbers satisfying the condition $x+y+z = 1$. The maximum possible value of\n\n$x^3y^3 + y^3z^3 + z^3x^3$\n\nhas the form $\\frac {a} {b} ,$ where $a$ and $b$ are positive, coprime integers. What is the value of $a+b$?\n\n×" ]

[ null ]

[ "Attention!\n\nAttention!\n\nNote that this documents only the first revision of the touchpad. The second revision (October 2005 powerbooks) is supported in appletouch as well, while the third revision (Macbook Pro) isn't supported yet because the device reports actual HID events, but these are low resolution and not too useful.\n\nThe touchpad claims to be a HID device but doesn't really send HID events as far as I can tell, but rather its own transfers.\n\n## transferred data\n\nThe trackpad continually transfers an 81 byte block via a USB interrupt transfer.\n\n### button\n\nThe last byte of the transferred 81 bytes indicates the button status, it is 0x01 if the button is pressed, 0x00 otherwise.\n\n### touch\n\nThe other 80 bytes are split into two 40 byte sections, the latter always being zerofilled. The following discusses the first 40 byte block of the transfer.\n\nLet me introduce the following mapping function (written in python notation):\n\n```def map(bytenumber):\nreturn bytenumber % 5, bytenumber/5\n```\n\nThen, in X direction, the touchpad has first the sensors with first component being even, in lexical order:\n\n```(2,0),(2,1),(2,2),....,(2,7),(4,0),...(4,7)\n```\n\nSame in Y direction with the first components 1 and 3. I'll refer to them as X through X and Y through Y.\n\nThose values with first component 0 seem to signify some other level that only covers the left part of the touchpad in X direction, but are less sensitive. I haven't used them.\n\nNow, all these values seem to be potentials, but only their change is interesting.\n\nSo now consider the following function:\n\n```def accu(current_vector, old_vector, accu_vector):\n# current_vector is either X or Y\n# old_vector is None if no old values are known,\n# otherwise a set of old values\n# we change accu_vector which must have length 16, all initialised to 0\nif old_vector is None:\nfor i in range(16): old_vector[i] = current_vector[i]\nreturn\nfor i in range(16):\ntmp = old_vector[i] - current_vector[i]\nif tmp > 127: tmp -= 256\nif tmp < -127: tmp += 256\naccu_vector[i] -= tmp\n```\n\nIn the normal state, accu_vector will be 0, and only fluctuate slightly due to the touchpad characteristics. When you touch it though, these values increase depending on where the finger is in X and Y directions. That can be used to track the position of the finger. We used an approach that calculates the finger position by weighing:\n\n```half_weight = sum(accu_vector)\npos = None\ni = 0\nacc = 0\nif half_weight > threshold/2: # get rid of fluctuations\nwhile acc + accu_vector[i] < half_weight:\nacc += accu_vector[i]\ni += 1\nval = i + (half_weight - acc)/(0.0+accu_vector[i]) # weigh inside one of the 16 areas\n# val contains None if no finger or the current position\n```\n\nThis snippet calculates the finger position for one direction.\n\nNow this this you can implement pretty much everything you need. I recommend threshold = 20, but we're thinking of a different way to detect the finger. Also, multiple fingers are reported correctly, if there are two fingers on the touchpad you don't know on which of the 4 positions they are (unless this data is sent and we haven't seen it yet).\n\n## Docutils System Messages\n\nSystem Message: ERROR/3 (<string>, line 1); backlink\n\nUnknown target name: \"/driver\"." ]

[ null ]

[ "The Logistic Map is a model of population growth and decay, where a population size, given by x, is updated generation by generation. A population of 1 means maximum size, and 0 is extinction.\n\nThe rate of population growth is determined by a constant r that ranges in value from 0 to 4. If there was no death, each generation the new population would be r times the current population, i.e. r x, and the population would grow exponentially. But the model includes death (because of competition for limited resources) and this reduces the population by r x2 each generation. Thus, the logistic map models the interaction between birth and death processes in a population.\n\nThe equation that describes the population change each generation is therefore xnew = r x (1 - x).\n\nInfinite complexity from a simple equation\n\n## Exploring the Logistic Map\n\nThis app allows you to explore the behaviour of the logistic map xnew = r x (1 - x), including the ability to compare the evolution form different initial conditions.\n\nUse the slider to choose a value for the growth parameter r, and an initial size for each population. Click the Next buttons to move to a new generation. The value for the new population (a normalised value from 0 to 1) is shown and also plotted.\n\nr:\n\nPopulation 1:   Start   Current 0.5\n\nPopulation 2:   Start   Current 0.5\n\nStudy the behaviour of the populations for various values of the growth parameter r, and for different initial conditions.\n\n## Some things to consider\n\nTwo aspects of this population process are particularly important:\n\n1. How does the specific value of r effect the long term behaviour of x?\n2. How does the series of x values depend on the initial population value?\nTo explore these, try various values for r, and test the sensitivity to the initial value by looking at the convergence or divergence of the two populations over time.\n\nLook at the behaviour for the following ranges of r and make a table to record what you find: (you can type directly into the table below)\n\nrResults\n0 – 1\n1 – 2\n2 – 3\n3 – 3.45\n3.5\n3.56\n3.74\n3.83\n4\n\nWhen the population ends on a constant, fixed value, can you calculate what that value must be? (Hint: think about quadratic equations.)\n\n## Bifurcations and Chaos\n\nA bifurcation occurs when a solution to an equation suddenly splits into two, such as you will have seen in the logistic map when the value of r crosses 3 (if you didn't notice, run the above app with r = 2.95 and then r = 3.05). Repeated bifurcations lead to cycles with 4 values, then 8, 16 etc, before things get really crazy around r = 3.57.\n\nChaos is the mathematical term that describes when a system is infinitely sensitive to its starting conditions, i.e. even the tiniest difference in starting point leads to a completely different outcome. The mathematics of chaos is behind the somewhat over-dramatised Butterfly Effect that says the tiny change due to the beating of a butterfly's wings in Brazil can set off a tornado in Texas.\n\nFor values of r close to 4 it seems the logistic map could be chaotic, but how to tell for sure? Well, there is a famous result that says if a map has a 3-cycle, that is a solution where it keeps repeating the same three values over and over again, then it is chaotic.\n\nIn the next section you can visualise the long term population dynamics for a range of r values using a bifurcation diagram. This is a diagram that shows the long time behaviour of the map for each r — if it is a fixed value, then a single point is plotted, if it is a 2-cycle, the both points are shown, and so on. The first few progressive bifurcations are clearly seen, as is the chaotic region, including its contained islands of stability.\n\nSee if you can find a value of r that leads to a 3-cycle. Test your value with the app above." ]

[ null ]

[ "", null, "", null, "", null, "# Children’s Tylenol is a solution containing 32 mg/mL. The recommended dose for a 2-year-old child is 120 mg. How many milliliters should be given to the child?", null, "### Chemistry In Focus\n\n7th Edition\nTro + 1 other\nPublisher: Cengage Learning,\nISBN: 9781337399692\n\n#### Solutions\n\nChapter\nSection", null, "### Chemistry In Focus\n\n7th Edition\nTro + 1 other\nPublisher: Cengage Learning,\nISBN: 9781337399692\nChapter 17, Problem 64E\nTextbook Problem\n1 views\n\n## Children’s Tylenol is a solution containing 32 mg/mL. The recommended dose for a 2-year-old child is 120 mg. How many milliliters should be given to the child?\n\nInterpretation Introduction\n\nInterpretation:\n\nThe recommended dose of Tylenol in millimetres for a child is to be determined.\n\nConcept Introduction:\n\nDimensional analysis is used to set up and solve a unit conversion problem using conversion factors. Dimensional analysis is a way to convert units of measurement. In order to convert from one unit to another, the relationship between those units is to be known. These relationships are called conversion factors.\n\nTo perform a conversion between 2 units, a quantity given in a particular unit is converted into another unit. This type of conversion is as follows:\n\n(quantity given)×(conversion factor)=(quantity sought)\n\nA conversion factor is a fraction in which the numerator is the unit into which the quantity is to be converted and the denominator is the unit from which it is converted.\n\n### Explanation of Solution\n\nGiven information: Children’s Tylenol is a solution containing 32mg/mL. The recommended dose for a 2 year-old child is 120 mg.\n\nFirst, find the conversion factor. It is given that 32mg contains 1 mL Tylenol.\n\nTherefore, the conversion factor according to the definition is 1 mL32 mg\n\n### Still sussing out bartleby?\n\nCheck out a sample textbook solution.\n\nSee a sample solution\n\n#### The Solution to Your Study Problems\n\nBartleby provides explanations to thousands of textbook problems written by our experts, many with advanced degrees!\n\nGet Started\n\nFind more solutions based on key concepts\nGive the molecular formula for each of the following structural formulas.\n\nGeneral Chemistry - Standalone book (MindTap Course List)\n\n\"Red flags\" that can help to identify nutrition quackery include a. enticingly quick and simple answers to comp...\n\nNutrition: Concepts and Controversies - Standalone book (MindTap Course List)\n\nHow many centimeters are there in a kilometer?\n\nAn Introduction to Physical Science\n\nDescribe two ways an atom can become excited.\n\nHorizons: Exploring the Universe (MindTap Course List)\n\nReview. A light, unstressed spring has length d. Two identical particles, each with charge q, are connected to ...\n\nPhysics for Scientists and Engineers, Technology Update (No access codes included)\n\nIn what sense is a black hole actually black?\n\nFoundations of Astronomy (MindTap Course List)", null, "" ]

[ null, "https://www.bartleby.com/static/search-icon-white.svg", null, "https://www.bartleby.com/static/close-grey.svg", null, "https://www.bartleby.com/static/solution-list.svg", null, "https://www.bartleby.com/isbn_cover_images/9781337399692/9781337399692_largeCoverImage.gif", null, "https://www.bartleby.com/isbn_cover_images/9781337399692/9781337399692_largeCoverImage.gif", null, "https://www.bartleby.com/static/logo-full-footer.svg", null ]

[ "", null, "Hello everyone! I hope you all will be fine and having fun. Today, I am going to share my knowledge about How to use MATLAB input Function. In this tutorial I would like to tell you about the importance of getting data from the user in MATLAB. If you want to display the data to users, you need to get data from them as well according their requirements. I hope you have read How to use MATLAB ?\n\nIn this way the same source code written in MATLAB will give different result according to the requirements of the each user. So, in other words the source code becomes generic in this way. As we run the program, command window of the MATLAB asks user to enter the desired input. The results on this window are generated according to the Matlab input given by the user. You should also have a look at Laplace Transform in MATLAB.\n\n#### How to use MATLAB input Function\n\nHere, in this tutorial I will explain you the importance and the procedure about How to use MATLAB input Function. The one of the main advantage of getting the data from the user is, the algorithm becomes generic in this way. The different users can get different types of results from the same program according their requirements. The user has to enter the input on the command window and can get the desired results according to the given input.\n\n##### Getting User Data\n• First of all open your MATLAB software and go to the editor in MATLAB.\n• Write a simple code in editor as shown below.\n```clc\nx=input('Enter the value of x = ');\ny=input('Enter the value of y = ');\nx+y\n```\n• Move to the command window and observe the results.\n• As you Run the program you will automatically move to the command window.\n• Command window will ask to enter the value of the first variable, which is x in this case.\n• The result of the above program is shown in the figure below:\n\nNote:You should also have a look at these MATLAB projects as well:", null, "• After entering the value of x command window will ask to enter the value of the second variable, which is y in this case.\n• The figure shown below displays the above results.", null, "• As you enter the value of y and press Enter, you will be able to see the result of the addition of the both of the variables.\n• The result is shown in the figure below.", null, "• Till now, I have performed addition operation on the variables whose values are given by the users and the program shows the different results for each user.\n• You can also perform a lot of other operations on these variables.\n• Here, I am going to perform basic mathematics operations on these two variables.\n• The code for multiplication operation is shown below.\n```clc %clearing command window\nx=input('Enter the value of x = ');%takes the value of x from the user\ny=input('Enter the value of y = ');%takes the value of y from the user\nproduct = x*y %performing multiplication\n```\n• The input MATLAB code will look something as shown in below figure:", null, "• The result on the command window is shown in the figure below.", null, "• Now, I am going to perform the division operation on the both of the variables.\n• The source code for the division operation is shown below.\n```clc %clears comand window\nx=input('Enter the value of x = '); %takes the value of x from the user\ny=input('Enter the value of y = '); %takes the value of y from the user\nproduct = x/y %performing division operation\n```\n• The result of the above source code is shown in the figure below.", null, "• Similarly you can perform a lot of other operations on the variables whose values are given by the user.\n• So, that was the brief discussion about How to use MATLAB input Function.\n• Here’s the video in which I have explained in detail How to use MATLAB input Function:\n\nSo, that is all from the tutorial How to use MATLAB input Function. I hope you enjoyed this tutorial. If you find any sort of problem, you can ask in comments anytime without even feeling any kind of hesitation. I will try my level best to solve your issues in a better way, if possible. You should also have a look at Introduction to MATLAB. In my next tutorial I will elaborate that how to generate rectangular signals in MATLAB and how to manipulate them. I will further explore MATLAB in my later tutorials by making further projects on it and will share them with all of you as well. So, till then, Take Care 🙂" ]

[ null, "https://www.theengineeringprojects.com/wp-content/uploads/2017/05/MATLAB-input-300x183.jpg", null, "https://www.theengineeringprojects.com/wp-content/uploads/2017/05/1-11.png", null, "https://www.theengineeringprojects.com/wp-content/uploads/2017/05/2-7.png", null, "https://www.theengineeringprojects.com/wp-content/uploads/2017/05/3-7.png", null, "https://www.theengineeringprojects.com/wp-content/uploads/2017/05/MATLAB-input.jpg", null, "https://www.theengineeringprojects.com/wp-content/uploads/2017/05/4-9.png", null, "https://www.theengineeringprojects.com/wp-content/uploads/2017/05/5-4.png", null ]

[ "Programming Geek\nRated 4.7/5 based on 1446 reviews", null, "", null, "### All Permutations\n\nAll Permutations of a Set of Elements\n\nLet us have a set of n elements; the objective is to find all the possible permutations of this set. For example if we have a set of four elements viz. {a, b, c} then we need to print all the permutation of a, b and c as give below:\n\n1)      { a, b, c}\n2)      { a, c , b}\n3)      { b, a, c}\n4)      { b, c, a}\n5)      { c, a, b}\n6)      { c, b, a}\n\nClearly for a set of n elements there exists n! different permutations.  One way to generate permutations is to iterate through n nested loops but that will be hardcoded approach as n may vary from time to time.  So one flexible approach is to generate the permutation recursively.  Let us have a set of three elements {a, b, c,} now to generate permutation follow these steps:\n\n1) Fix a and generate permutation of { b, c }\n2) Fix b and generate permutation of { a, c }\n3) Fix c and generate permutation of { a, b }\n\nThe pseudo code for the recursive algorithm to generate all permutation is as below:\n\n```permute(a,k,n)\n{\nif(k==n) then print a[1..n] // output permutation\nelse\nfor i=k to n do\n{\nt=a[k];a[k]=a[i]; a[i]=t;\npermute(a,k+1,n); // all permutation of a[k+1..n]\nt=a[k];a[k]=a[i]; a[i]=t;\n}\n}\n\n```\nThe calling function takes inputs and calls permute function passing three arguments a list of elements, start index and end index.\n\nInside permute it is checked whether start index and end index are same (if there is only one element) or not. If both are same then print the permutation else iterate through for loop and call permute function recursively.\n\nThe following program implements this pseudo code in C :\n\n```#include<stdio.h>\nvoid permute(int* a,int k,int n);\n\nvoid main()\n{\nint i,n;\nint*a;\nscanf(\"%d\",&n);\na=(int*)calloc(n,sizeof(int));\n\nfor(i=0;i<n;i++)\nscanf(\"%d\",&a[i]);\npermute(a,0,n-1);\n}\n\nvoid permute(int* a,int k,int n)\n{ int i,t;\nif(k==n)\n{\nfor(i=0;i<=n;i++)\nprintf(\"%d\\t\",a[i]);\nprintf(\"\\n\");\n}else\n{\nfor(i=k;i<=n;i++)\n{\nt=a[k];\na[k]=a[i];\na[i]=t;\npermute(a,k+1,n);\nt=a[k];\na[k]=a[i];\na[i]=t;\n}\n}\n}\n\n```\n\nThe output of the following program is as shown below:\n\nLet us observe the output one by one:\n\nThe first line of input 3 is the number of elements to be entered y the user.\nThe second line of input consists of three input numbers 1, 2 and 3.\nThe remaining 6 lines are all permutations of the input elements i. e. all permutations of 1, 2 and 3.\nMain function call permute function passing a, 0 and 2 as parameters.\n\nFirst Call\n\nInside permute if condition is false hence else is executed. In else since i=0 and k=0 so no swapping. Here we have k=0, i=0 and  a=1,a=2 and a=3. Now call again permute passing a, k+1(=1) and n(=2) as parameters.\n\nSecond Call\n\nThe value of  k and n differs so again else is executed. Inside else value of k and I is same so no swapping occurs hence i=1,k=1 and a=1, a=2 and a=3. Call again permute function passing a, k+1(=2) and n(=2) as parameters.\n\nThird Call\n\nThe value of k and n are same i.e. 2 hence if is executed and inside if content of list a is printed i. e. 1 2 3.\n\nNow control is transferred back to calling function i. e. to Second Call\n\n[Third Call ends here]\n\nInside second Call again swap occurs. But i=1 and k=1 so actually no swapping. Again i is incremented by 1 hence value of i=2 and k=1 so swapping occurs i. e.  now a becomes a=1, a3 and a=2 and now call permute passing a, k+1(=2) and n(=2) as parameters.\n\nFourth Call\n\nThe value of k and n are same i.e. 2 hence if is executed and inside if content of list a is printed i. e. 1 3 2.\n\nNow control is transferred back to calling function i. e. to Second Call\n\n[Fourth Call ends here]\n\nInside second call swapping occurs as value of i=2 and k=1 so a=1,a=2 and a=3. i is incremented by 1 and for condition becomes false hence control is transferred back to calling function i.e. First Call.\n\n[Second call ends here]\n\nInside First Call Value of i and k are 0 hence again no swapping. Now i is incremented by 1 and it becomes 1. Now swapping occurs as i=1 and k=0. Hence revised list a is as a=2, a=1 and a=3. And now call again permute  function passing a, k+1(=1) and n(=2) as parameters.\nHence now again Second Call, Third Call and Fourth Call is repeated and following gets printed i.e. 2 1 3 and 2 3 1 and values of list a are a=2, a=1 and a=3.\n\nAgain inside First Call swapping occurs as i=1 and k=0 and list a becomes a=1, a=2 and a=3.\nNow i is incremented by 1 i. e. i becomes 2 now and k is 0  hence swapping occurs i. e. a= and a=2 and a=2 and  permute function is called passing a, k+1(=1) and n(=2) as parameters. Hence now again Second call Third Call and Fourth Call is repeated and following gets printed i. e. 3 2 1 and 3 1 2.\n\nAgain inside First call values are swapped and values of list a are a=1, a=2 and a=3\n[First Call ends here]\n\nHence values of list a remains intact after the completion of all recursive calls and all permutations are printed." ]

[ null, "https://etest.programminggeek.in/assets/images/favicon.png", null, "https://etest.programminggeek.in/assets/images/favicon.png", null ]

[ "Version: 2022.3\nLanguageEnglish\n• C#\n\n# Transform.InverseTransformDirection\n\nSuggest a change\n\n## Success!\n\nThank you for helping us improve the quality of Unity Documentation. Although we cannot accept all submissions, we do read each suggested change from our users and will make updates where applicable.\n\nClose\n\n## Submission failed\n\nFor some reason your suggested change could not be submitted. Please <a>try again</a> in a few minutes. And thank you for taking the time to help us improve the quality of Unity Documentation.\n\nClose\nSwitch to Manual\n\n## Declaration\n\npublic Vector3 InverseTransformDirection(Vector3 direction);\n\n### Description\n\nTransforms a `direction` from world space to local space. The opposite of Transform.TransformDirection.\n\nThis operation is not affected by scale or position of the transform. The transformed vector has the same length as the original.\n\nIf you need the inverse operation to transform from local space to world space you can use Transform.TransformDirection\n\nYou should use Transform.InverseTransformPoint if the vector represents a position in space rather than a direction.\n\nIf you need to transform many directions at once consider using Transform.InverseTransformDirections instead as it is much faster than repeatedly calling this function.\n\n```using UnityEngine;public class Example : MonoBehaviour\n{\nvoid Start()\n{\n// transform the world forward into local space:\nVector3 relative;\nrelative = transform.InverseTransformDirection(Vector3.forward);\nDebug.Log(relative);\n}\n}\n```\n\n## Declaration\n\npublic Vector3 InverseTransformDirection(float x, float y, float z);\n\n### Description\n\nTransforms the direction `x`, `y`, `z` from world space to local space. The opposite of Transform.TransformDirection.\n\nThis operation is not affected by scale or position of the transform. The transformed vector has the same length as the original.\n\nIf you need the inverse operation to transform from local space to world space you can use Transform.TransformDirection\n\nYou should use Transform.InverseTransformPoint if the vector represents a position in space rather than a direction.\n\nIf you need to transform many directions at once consider using Transform.InverseTransformDirections instead as it is much faster than repeatedly calling this function.\n\n```using UnityEngine;public class Example : MonoBehaviour\n{\nvoid Start()\n{\n// transform the world forward into local space:\nVector3 relative;\nrelative = transform.InverseTransformDirection(Vector3.forward);\nDebug.Log(relative);\n}\n}\n```" ]

[ null ]

[ "Share\n\n# Seven Rods A, B, C, D, E, F and G Are Joined as Shown in Figure (28-e9). All the Rods Have Equal Cross-sectional Area a and Length L. the Thermal Conductivities of the Rods Are Ka = Kc = K0, Kb - Physics\n\nConceptThermal Expansion of Solids\n\n#### Question\n\nSeven rods A, B, C, D, E, F and G are joined as shown in the figure. All the rods have equal cross-sectional area A and length l. The thermal conductivities of the rods are KA = KC = K0, KB = KD = 2K0, KE = 3K0, KF = 4K0 and KG = 5K0. The rod E is kept at a constant temperature T1 and the rod G is kept at a constant temperature T2 (T2 > T1). (a) Show that the rod F has a uniform temperature T = (T1 + 2T2)/3. (b) Find the rate of heat flowing from the source which maintains the temperature T2.", null, "#### Solution", null, "Given:\n\nKA = KC = K0\n\nKB = KD = 2K0\n\nKE = 3K0, KF = 4K0\n\nK9= 5K0\n\nHere, K denotes the thermal conductivity of the respective rods.\n\nIn steady state, temperature at the ends of rod F will be same.\n\nRate of flow of heat through rod A + rod C = Rate of flow of heat through rod B + rod D\n\n(K_A·A·(T-T_1))/ ( l ) + (K_c·A(T-T_1))/(l) +  (K_B·A( T_2 - T ))/l\n\n2k0 ( T - T) = 2 × 2 K0 ( T2 - T)\n\nTemp of rod F = T =  (T_1 + 2T_2)/3\n\n(b) To find the rate of flow of heat from the source (rod G), which maintains a temperature T2 is given by\n\nRate of flow of heat, q = (DeltaT)/(\"Thermal resistance\")\n\nFirst, we will find the effective thermal resistance of the circuit.\n\nFrom the diagram, we can see that it forms a balanced Wheatstone bridge.\n\nAlso, as the ends of rod F are maintained at the same temperature, no heat current flows through rod F.\n\nHence, for simplification, we can remove this branch.\n\nFrom the diagram, we find that Rand RB are connected in series.\n\n∴ RAB = RA + RB\n\nRC and Rare also connected in series.\n\n∴ RCD = RC + RD\n\nThen, RAB and RCD are in parallel connection.\n\nR_A  = l/(K_0A)\n\nR_B = l/(2K_0A)\n\nR_C = l /( K_0A)\n\nR_D = l/(2K_0A)\n\nR_{AB} = (3l)/(2k_0A)\n\nR_{CD} = (3l)/(2K_0A)\n\nR_\"eff\" = ((3l)/(2K_0A)xx(3l)/(2K_0A))/ (((3l)) /( 2K_0A) + (3l)/(2K_0A))\n\n=(3l)/(4K_0A)\n\n⇒ q = (DeltaT)/(\"R_eff\")\n\n= (T_1 - T_2)/((3l)/ (4K_0A))\n\n⇒ (4K_0A(T_1 - T_2))/(3L)\n\nIs there an error in this question or solution?\n\n#### APPEARS IN\n\nSolution Seven Rods A, B, C, D, E, F and G Are Joined as Shown in Figure (28-e9). All the Rods Have Equal Cross-sectional Area a and Length L. the Thermal Conductivities of the Rods Are Ka = Kc = K0, Kb Concept: Thermal Expansion of Solids.\nS" ]

[ null, "https://www.shaalaa.com/images/_4:14148c71b2b042548dd441a8a4829f96.png", null, "https://www.shaalaa.com/images/_4:f61d2bdab38248378d05480a89be8070.png", null ]

[ "# How to Find Sale Price", null, "••• Natee Meepian/iStock/GettyImages\n\nBig sale discounts are nice, but how much will that new video game, dress or even a new house really cost? In order to figure out how much of the cost the discount takes away and how much is left for you to pay, you'll have to master the concept of percentages.\n\n#### TL;DR (Too Long; Didn't Read)\n\nSale price = original price × (1 − percent of discount). For this to work, the percent of discount must be expressed as a decimal.\n\n### Defining Percent of a Price\n\n\"Percent\" actually means \"out of one hundred,\" so it might help to think of the item's price as a pie that's been cut into one hundred tiny, equal parts. The percentage of the discount is how many of those itty-bitty pieces get taken away, and the number of pieces left indicates the percent of the original price that you pay. So if that dress you're looking at is on sale at a 30 percent discount, once you take those 30 percent pieces away you'll have 100 − 30 = 70 percent pieces left. So you'll end up paying 70 percent of the original price.\n\n### Calculating the Sale Price\n\nNow that you understand how the percent discount relates to the sale price, it's time to find the sale price. Consider the example of a video game that costs $60, but is on sale for 10 percent off. How much will the sale price be after you take the discount? Subtract the percent of the discount (in this case, 10 percent) from 100 to find how much of the original price you'll still pay. In this example, that means: 100 - 10 = 90 \\text{ percent} So the sale price of the video game will be 90 percent of the original price. Divide by 100 to convert the result of the previous step to a decimal. So the percentage that represents your sale price becomes: 90 ÷ 100 = 0.9 Multiply the decimal result from Step 2 by the original price of the game. Since the game originally cost$60 and you know you'll be paying 90 percent (or 0.9, in decimal form) of that price after taking the sale discount, you have:\n\n\\$60 × 0.9 = \\$54\n\nThe result of this step is your sale price after taking the discount.\n\n### Calculating Backward to the Original Price\n\nDo you have the sale price of an item and want to know what the original price was? If you know the percent of the discount taken, you can figure it out. Consider a jacket that cost $90 on sale, after taking a 20 percent discount. What was the original price? Subtract the percentage of the discount from 100. The result is the percentage of the original price that you paid. In this case, that means: 100 - 20 \\text{ percent} = 80 \\text{ percent} So the price you paid – in this case,$90 – represents 80 percent of the original cost.\n\nDivide your result from the previous step – here, that's 80 percent – by 100 to convert it to a decimal:\n\n80 ÷ 100 = 0.8\n\nDivide the sale price of the item – in this case, $90 – by the percentage paid of the original price. The result will be the original price of the item, before taking any sale discounts. Since you know you paid 80 percent or 0.8 of the original price, that works out to: \\$90 ÷ 0.8 = \\\\$112.50\n\nDont Go!\n\nWe Have More Great Sciencing Articles!" ]

[ null, "https://img-aws.ehowcdn.com/360x267p/s3-us-west-1.amazonaws.com/contentlab.studiod/getty/50e222351fc54db4a1195f289a57abb6.jpg", null ]

[ "# Law of Multiple Proportions: Dalton's Law", null, "The law of multiple proportions is one of the weight laws of chemistry. The law states that if two chemical elements form more than one compound, the proportion of the mass of the second element that combine with a fixed mass of the first element will always be proportions of simple integers.\n\nJohn Dalton expressed the law of multiple proportions in 1804.\n\n## On What Phenomenon Was Dalton Based That Proust Did Not Realize?\n\nA few years earlier, the French chemist Joseph Proust had proposed the law of definite proportions.\n\nWith the works of Prous a phenomenon occurred that Proust did not realize: there are some chemical elements that are related in different proportions to form different chemical compounds. Dalton took advantage of this phenomenon for his research.\n\nThe law of definite proportions stated that elements combine to form compounds in certain well-defined proportions with a relationship of whole numbers.\n\nLater, Antoine Lavoisier proved the law of conservation of mass, which helped Dalton.\n\n## What Is the Relationship Between the Law of Multiple Proportions and Dalton's Atomic Model?\n\nDalton's law was a key proof of atomic theory.\n\nToday, there is a question whether Dalton discovered the law from a hypothesis to investigate the validity of his atomic theory or he discovered it by accident and then explained it using atomic theory.\n\n## What Other Law Is Dalton's Law Confused With?\n\nThis law is sometimes called Dalton's law, after John Dalton, the chemist who first expressed it. However, as with Gay-Lussac's law, the name Dalton's law is sometimes used to refer to another law: the law of partial pressures. That is, the calculation of the partial pressures of a gas mixture applying the ideal gas law to each component.\n\nThe law of partial pressures states that the total pressure of a mixture of gases is equal to the sum of the pressures that each of them would exert if only one of them occupied the entire volume. This law is fulfilled only if the gases do not react chemically and are at constant temperature.\n\nAuthor:\n\nPublished: December 12, 2021\nLast review: December 12, 2021" ]

[ null, "https://nuclear-energy.net/uploads/cms/energy/chemical-energy/laws-of-chemistry/law-of-multiple-proportions.webp", null ]

[ "Research Article | Open Access\n\nVolume 2016 |Article ID 3251082 | https://doi.org/10.1155/2016/3251082\n\nShichao Chen, Ming Liu, Jun Wang, Fugang Lu, Mengdao Xing, \"Focusing of Spotlight Tandem-Configuration Bistatic Data with Frequency Scaling Algorithm\", International Journal of Antennas and Propagation, vol. 2016, Article ID 3251082, 15 pages, 2016. https://doi.org/10.1155/2016/3251082\n\n# Focusing of Spotlight Tandem-Configuration Bistatic Data with Frequency Scaling Algorithm\n\nAccepted01 Sep 2016\nPublished06 Nov 2016\n\n#### Abstract\n\nA frequency scaling (FS) imaging algorithm is proposed for spotlight bistatic SAR data processing. Range cell migration correction (RCMC) is realized through phase multiplication. The proposed algorithm is insensitive to the length of the baseline due to the high precision of the point target (PT) spectrum that we are based on. It is capable of handling bistatic SAR data with a large baseline to range ratio. The algorithms suitable for small and high squint angles are both discussed according to whether the range dependence of the second range compression (SRC) can be neglected or not. Simulated experiments validate the effectiveness of the proposed algorithm.\n\n#### 1. Introduction\n\nBistatic synthetic aperture radar (SAR) imaging has been widely discussed in recent years . Besides the synchronization problems [5, 6], fast imaging algorithms are still in search. However, we cannot acquire accurate bistatic point target (PT) spectrum through the principle of stationary phase (POSP) because of the double-square-root term existing in the range history of bistatic SAR. Although the time domain method is the best in theory, it accomplishes optimum reconstruction with heavier computational burden than the frequency domain imaging algorithms . The numerical methods can handle the bistatic SAR focusing well; however, they also suffer the computational burden . The accurate analytical PT spectrum is the precondition of designing most fast bistatic imaging algorithms in the frequency domain, and some effective spectra in the frequency domain have been presented recently , and many imaging algorithms have been proposed based on them. Tandem bistatic SAR has a simple formation and is relatively easy to accomplish in engineering, which has a bright future in multiple applications [18, 19]. Wu et al. [20, 21] deduced an exact analytical PT spectrum of bistatic SAR in stripmap mode based on the concept of instantaneous Doppler wavenumber (IDW) in tandem configuration.\n\nWe focus on the well-known tandem configuration here. A frequency scaling (FS) imaging algorithm is proposed in this paper for bistatic SAR imaging in spotlight mode based on the spectrum presented in . The process is implemented in the frequency domain, and no interpolation is needed. The azimuth spectral folding effect is solved by the combination of the subaperture approach and the deramping process, when the azimuth bandwidth is larger than the pulse repetition frequency (PRF). Due to the high precision of the spectrum, the proposed algorithm is capable of handling bistatic SAR data with a large baseline.\n\nThe paper is organized as follows. In Section 2, the geometry and the signal model of spotlight bistatic SAR are introduced. The proposed FS algorithm is discussed in detail in Section 3 for both small and high squint angles. And the performance of the proposed algorithm is given in Section 4 with simulations. Conclusions are drawn in Section 5.\n\n#### 2. Geometry Relationship and Signal Model of Spotlight Bistatic SAR\n\nFigure 1 shows the geometry of spotlight bistatic SAR, the antenna is constantly steering to the imaging spot during the whole synthetic aperture time to realize a finer azimuth resolution. and represent the transmitter and the receiver, respectively. They travel along the same track with the same velocity , and and are the slant distances from the target to the transmitter and the receiver, respectively. and are the corresponding squint angles. is the closest distance from the target to the flight track, is the half bistatic angle, and is half the length of the baseline.\n\nIn spotlight mode, suppose that radar transmits the linear frequency-modulated (LFM) pulses, and the echo signal after dechirp on receiver can be written aswhere stands for the bistatic backscattering coefficient,represents the rectangular window, is the shape of the antenna illumination, is the displacement of the platform in azimuth, and and are the fast and dwell time, respectively. is the pulse duration, is the chirp rate, is the reference range for dechirp, is the closest distance from the scene center to the flight track, is the speed of light, is the carrier frequency, and .\n\nTransforming the signal into the range wavenumber domain, in case of large time bandwidth product , the signal can be expressed aswhere is the range wavenumber, is the center of , is the variation of the range wavenumber, , and “” means the convolution operation.\n\n#### 3. Bistatic FS Algorithm\n\n##### 3.1. FS Imaging Algorithm for Tandem Bistatic SAR with Small Squint Angles\n\nTransforming the signal into the two-dimensional (2D) wavenumber domain based on the IDW concept , we havewhere represents the Doppler wavenumber and indicates the azimuth position where the imaged target is located.\n\nThe proposed FS imaging algorithm is based on this equation. Wu et al. deduced an exact analytical expression of the half bistatic angle for tandem bistatic SAR . After substituting it into (4) and making Taylor series expansion up to the cubic term with respect to , the signal comes to\n\nThe detailed expressions of , , , , and are given in Appendix. The expressions may seem rather complicated due to the complex formation of the spectrum. However, they will turn to be the familiar azimuth modulation term , the range cell migration (RCM) factor , and the second range compression term in monostatic case when , .\n\nIn the following, we fit a straight line to the RCM factorwhere , , and . To see the physical implications of the parameters clearly, again, we can get and , which is just the familiar scale factor in monostatic case when , . The profile error caused by (6) is much smaller than the range resolution and can be neglected.\n\nSubstituting (6) into (5), the signal arrives at\n\nTo equalize the RCM of all the ranges to the one of the scene center, resembling the monostatic case , the frequency scaling function is given aswhere and is the center of . and are the squint angles from the scene center to the transmitter and the receiver at zero time. The reason for introducing into the scale factor is to reduce the amount of shift in range caused by the scaling operation when the squint angles are high, ensuring that the signal after scaling is still in the bandwidth that we are dealing with. When the system works with small squint angles, can be chosen accordingly. Details about this issue are discussed in in monostatic case.\n\nThe multiplication between (7) and (8) results in\n\nFrom the comparison between (7) and (9), it can be seen that the space-variant term in the RCM term has been eliminated. The linear phase term that indicates the range position of the target and the bulk range shift term have emerged. After an inverse fast Fourier transform (IFFT) in range, is multiplied by the signal to correct the range time shift caused by the term called the residual video phase (RVP), which results from the dechirp operation on receiverwhere indicates the range summation of the transmitter and the receiver of bistatic SAR and and are Fourier transform pairs.\n\nAgain, transforming the signal into the 2D wavenumber domain, the signal moves to\n\nThen, the inverse frequency scaling function is introduced to correct the second-order range phase error caused by the frequency scaling operation\n\nThe following operation is the bulk range shift function for the RCMC:\n\nThe range dependence of SRC can be neglected when the bistatic SAR system works with small squint angles, and it can be compensated with the parameters of the scene center. The SRC function is given aswhere and . The residual phase error caused by the approximation will be smaller than , which will not give a crucial influence to the final imaging quality. However, when the squint angles are high enough, neglecting the influence of the approximation will no longer be available. In this situation, we can extend the nonlinear chirp scaling algorithm (NCSA) of the monostatic case into the bistatic one.\n\nThe operations in range are finished after transforming the signal into the domain.\n\nIf the azimuth bandwidth is smaller than PRF, the azimuth compression filter can be directly given as\n\nNote that, due to the change of the image in range as is shown in (11), we have to accommodate the range parameter into , so are the range-dependent variables and . At the end of the whole imaging process, an IFFT is performed in azimuth to transform the focused data into the complex image domain.\n\nHowever, the PRF is usually smaller than the whole azimuth bandwidth in practice in spotlight mode, especially in spaceborne case; thus the imaging algorithms cannot be directly applied into the whole aperture because of the spectral folding effect. One way to solve the problem is the subaperture method and combining it with the deramping process. The data is divided into several subapertures according to the azimuth time, ensuring that the bandwidth within each subaperture is smaller than PRF. The FS algorithm is then implemented in each subaperture.\n\nIn the following, we come to get the high-order phase compensation function to transform the bistatic azimuth phase history into a purely quadratic one as the monostatic case . Making Taylor series expansion of the phase term in (15) with respect to\n\ncontains the high-order terms of . After the compensation of , the purely quadratic term emerges. On analog of the monostatic case , the deramping function is given after an IFFT with respect to where and are the start and the end time of the th subaperture and is the central time of the th subaperture. In the end, the interested image is obtained with a full aperture FFT in azimuth after the subapertures are recombined.\n\nTo summarize and make the proposed FS algorithm more clearly, the workflows of the proposed FS algorithm are given as follows: (1) divide the bistatic SAR data into subapertures; (2) perform azimuth FFT and implement the frequency scaling by (8); (3) perform range IFFT and implement residual video phase correction by (10); (4) perform range FFT and implement the inverse frequency scaling by (12), the bulk range shift for RCMC by (13), and the second range compression by (14); (5) perform range IFFT and implement high-order terms compensation with respect to the Doppler wavenumber; (6) perform azimuth IFFT and implement deramping by (17); and (7) recombine the subapertures and perform full aperture azimuth FFT to obtain the final bistatic SAR image. The block diagram of the proposed FS imaging algorithm is shown in Figure 2.\n\n##### 3.2. FS Imaging Algorithm for Tandem Bistatic SAR with High Squint Angles\n\nIn some cases, the bistatic SAR system works with high squint angles, such as observing the interested object which is squint-depended or inspecting the front situations. The range dependence of SRC has to be taken into account in such cases. Taking (14) to compensate the SRC would be inappropriate, the residual phase error will be larger than , and ideal focusing quality cannot be guaranteed. Facing the problem, one instinctive way is to extend the NCSA in monostatic case into the bistatic one. Although the problem can also be solved by processing small range blocks, it requires a large overlap of blocks, which will make the process inefficient .\n\nTo eliminate the range dependence of SRC, firstly, a third-order filter term is introduced\n\nThe coefficient will be given subsequently. Similar to the monostatic case, we believe in the approximation that the third-order term of SRC can be compensated by the parameters of the scene center. In the same time a new third-order phase term is introduced, and thus the second-order term in the SRC is preserved for the scaling operation. The SRC term shown by (14) is replaced by (18) accordingly. And the signal arrives atwhere . Using the POSP and neglecting the influence of the third-order phase to the stationary point, the signal is subsequently transformed into the domain\n\nMultiply the signal by the nonlinear scaling function which is constructed as\n\nA range FFT is performed to the signal after the multiplication between (20) and (21). We take a close look at the phase term\n\nDue to the range dependence of , we fit it by a straight linewhere and , provided that the following approximations are met:\n\nSubstituting (23) and (24) into (22), the phase term comes towhere\n\nMaking and to eliminate the terms that are space-variant, we get , , and . The scaling factor , and is chosen to be here, and the value can be adjusted for satisfying imaging results . Substituting the results into (25), the signal arrives at\n\nAs can be seen, the range dependence of SRC has been eliminated. The function for range compression is given as\n\nAnd, then, the phase correction factor is given as\n\nTo construct accurate azimuth compression filter, we have to accommodate into according to (27), so are the range-dependent parameters and :\n\nAn azimuth IFFT is performed to transform the focused data into the complex image domain in the end.\n\nSimilarly, we summarize the proposed nonlinear FS algorithm that is suitable for high squint angle bistatic SAR. The corresponding workflows are given as follows: (1) perform azimuth FFT and implement frequency scaling by (8); (2) perform range IFFT and implement residual video phase correction by (10); (3) perform range FFT and implement the inverse frequency scaling by (12), the bulk range shift for RCMC by (13), and the third-order filter by (18); (4) perform range IFFT and implement nonlinear frequency scaling by (21); (5) perform range FFT and implement the second-order range compression by (28); (6) perform range IFFT and implement phase correction by (29) and azimuth compression by (30); and (7) perform azimuth IFFT to obtain the final bistatic SAR image. The block diagram is shown in Figure 3.\n\nFrom the above discussion, we can tell that the range history of bistatic SAR is the sum of two square roots, which results in different bistatic spectrum from the monostatic case. The different bistatic spectrum leads to different range cell migration. Thus the conventional FS algorithm cannot be directly utilized into the bistatic case. In this paper, we design a new frequency scaling algorithm which is suitable for bistatic case. The proposed bistatic frequency scaling function is established based on an exact analytical bistatic spectrum to realize range-dependent RCM correction. And the corresponding functions for bistatic FS algorithm are also established, such as the inverse frequency scaling function, the residual video phase correction function, the range migration correction function, and the second range compression function. We construct all these new functions based on the bistatic spectrum. Besides, the range-dependent parameters need to be updated for bistatic case. In addition, a nonlinear frequency scaling algorithm is proposed to deal with the high squint angle bistatic SAR based on the analytical bistatic spectrum. We also establish the functions of the nonlinear FS algorithm for bistatic SAR accordingly. Although these functions for the bistatic FS algorithm are much more complex than the monostatic one, fortunately, we can evaluate the correctness of the algorithm by degenerating the conditions into the monostatic case. In practice, we can choose the suitable algorithm according to the squint angles.\n\n#### 4. Simulation Results\n\n##### 4.1. Simulations with Small Squint Angles\n\nExperiments are carried out to validate the effectiveness of the proposed algorithm. Table 1 illustrates the main parameters of the experiment in three cases in tandem configuration. We put nine point targets in the imaging scene with the center one located at . The distance between any two neighboring targets is 1500 m in both range and azimuth. Taking Case I for illustration, the profile error caused by the linear approximation of the RCM (6) is shown in Figure 4, which is far less than the range resolution. The influence can be neglected. The residual phase error of SRC for the edge target compensated by the local (14) is shown in Figure 5. As can be seen, the error is tolerable. The final imaging results of the center and the edge target by using the proposed FS algorithm are shown in Figure 6. We can see that they are quite well focused; the detailed values of the impulse-response width (IRW), the peak sidelobe ratio (PSLR), and the integrated sidelobe ratio (ISLR) are shown in Table 2 with theoretic values (IRW, PSLR, and ISLR) 0.75 m in range, 1 m in azimuth, −13.3 dB, and −10 dB, respectively.\n\n Case I Case II Case III Range bandwidth 200 MHz PRF 3000 Hz Carrier frequency 10 GHz Platform velocity 7000 m/s Closest distance from the flight track to the scene center 600 km Illumination time 1.34 s 1.44 s 1.61 s Range to reference target 611.9 km 635.7 km 670.8 km Length of the baseline 240 km 420 km 600 km Squint angle 11.31°(T) −11.31°(R) 19.29°(T) −19.29°(R) 26.57°(T) −26.57°(R)\n Range Azimuth Resolution (m) PSLR (dB) ISLR (dB) Resolution (m) PSLR (dB) ISLR (dB) Reference 0.75 −13.2626 −9.7577 1.0625 −13.2669 −9.7605 Edge 0.75 −13.2618 −9.7502 1.0625 −13.2639 −9.7520\n\nTo show the advantage of the proposed algorithm, we compare it with the MSR and DMO spectra based algorithms. Satisfying focusing quality can be obtained by using all the algorithms for Case I except the DMO based one. For Case II, the baseline increases to 420 km, and the imaging results obtained by using different algorithms are shown in Figures 79, respectively. As can be seen, the center target is still well focused by using both the proposed and the MSR based algorithms, while the imaging result obtained by using the DMO spectrum based algorithm is much worse than the others. As for the edge target, the focusing qualities differ much under different algorithms. As can be seen, the one obtained by using the proposed algorithm is the best.\n\nIn the following, we come to Case III with the baseline 600 km; corresponding imaging results by using the algorithms are shown in Figures 1012, respectively. Again, ideal focusing results can be obtained for the center target with both the proposed and the MSR spectrum based algorithms but not the DMO spectrum based one. The focusing quality degrades dramatically with the increasing length of the baseline. As for the edge target, the focusing qualities are intolerable by using all the algorithms except the proposed one. As can be seen, the focusing quality for the edge target decreases by using the DMO and the MSR based algorithms in this case. The reason for the phenomenon lies in the fact that, with the increasing length of the baseline, the precision of the DMO and MSR spectrum degrades, and the corresponding imaging results based on them degrade accordingly. The detailed values of the IRW, PSLR, and ISLR of the center target under different algorithms for Case II and Case III are shown in Table 3, and the corresponding descriptions of the edge target are given in Table 4.\n\n Range Azimuth Resolution (m) PSLR (dB) ISLR (dB) Resolution (m) PSLR (dB) ISLR (dB) Case II (the proposed) 0.75 −13.2537 −9.7736 1.0625 −13.2740 −9.7137 Case II (the MSR based) 0.75 −13.2464 −9.7753 1.0625 −13.2728 −9.7131 Case II (the DMO based) 0.75 −13.2636 −9.7792 5.8125 −0.0102 5.1913 Case III (the proposed) 0.75 −13.2346 −9.7749 1.0625 −13.2725 −9.7115 Case III (the MSR based) 0.75 −13.2579 −9.7751 1.0625 −13.2721 −9.7087 Case III (the DMO based) 0.75 −13.2427 −9.7687 5.9375 −00005 8.2978\n Range Azimuth Resolution (m) PSLR (dB) ISLR (dB) Resolution (m) PSLR (dB) ISLR (dB) Case II (the proposed) 0.75 −13.2648 −9.7708 1.0625 −13.2669 −9.7605 Case II (the MSR based) 0.75 −13.2618 −9.7542 1.375 −11.1847 −7.9352 Case II (the DMO based) 0.75 −13.2365 −9.7750 5.8750 −0.0087 8.2852 Case III (the proposed) 0.75 −13.2626 −9.7577 1.0625 −13.2547 −9.7269 Case III (the MSR based) 0.75 −13.2583 −9.7502 1.6875 −4.0652 −2.9469 Case III (the DMO based) 0.75 −13.2398 −9.7722 6.0625 −00004 8.8628\n\nWe can tell that the proposed algorithm is capable of dealing with spotlight bistatic SAR data with a large baseline. Note that, for the MSR spectrum based algorithm, we only expand the Taylor series expansion up to the third term for comparison here. For better focusing quality of the MSR based algorithm, higher orders can be expanded.\n\n##### 4.2. Simulations with High Squint Angles\n\nIn the following, we take a look at the case with high squint angels. The main parameters are shown in Table 5. Nine point targets are put in the imaging scene with the center one located at . The distance between any two neighboring point targets is 400 m in both range and azimuth. The distances from the center target to the transmitter and the receiver are 17.47 km and 10.99 km, respectively. Corresponding squint angles are 62.75° and 43.28°, respectively. The PRF is larger than the azimuth bandwidth in this case, so the proposed FS imaging algorithm can be applied onto the whole aperture.\n\n Wavelength Pulse duration Transmitted bandwidth Platform velocity PRF Doppler bandwidth Reference distance 0.03 m 30 us 250 MHz 110 m/s 600 Hz 220 Hz 8000 m\n\nIf the parameters of the scene center are still chosen to compensate the range-dependent SRC, the residual phase error will be larger than , as shown in Figure 13. Imaging results for the center and the edge targets are shown in Figure 14 if the algorithm suitable for small squint angles is adopted. It can be seen that the center target can be well focused, but the focusing quality of the edge target degrades dramatically. The results obtained by using the proposed algorithm suitable for high squint angles are shown in Figure 15. We can tell that the focusing quality for the edge target has improved explicitly from the comparison between Figures 14(b) and 15(b). It implies that the range dependence of SRC must be taken into consideration in this case. To show the advantage of the proposed algorithm, the MSR based algorithm is carried out for comparison. Corresponding imaging results are shown in Figure 16. Detailed descriptions of the focusing quality of the edge target under different algorithms are shown in Table 6.\n\n Range Azimuth Resolution (m) PSLR (dB) ISLR (dB) Resolution (m) PSLR (dB) ISLR (dB) Algorithm for high squint angles 0.6 −13.2751 −9.6878 0.5 −13.2431 −9.7215 Algorithm for small squint angles 1.9125 −3.4346 −3.0418 0.7813 −9.2565 −6.7511 The MSR based algorithm 0.6 −13.2431 −9.7331 0.7188 −9.7331 −8.2379\n\nIn practice, when the data is obtained, we can determine the SRC to test the amplitude of the residual phase error and choose the proper imaging algorithm subsequently.\n\n#### 5. Conclusion\n\nAn FS algorithm suitable for tandem bistatic SAR in spotlight mode is proposed, which is insensitive to the baseline to range ratio. The subaperture approach and the deramping process are combined to handle the problem of the azimuth spectral folding effect like the monostatic case. Ideal focusing results are obtained in the frequency domain without interpolation. A nonlinear FS algorithm is also discussed to deal with the tandem bistatic data with high squint angles, in which situation the range dependence of SRC must be taken into consideration. Satisfactory results are obtained with simulated experiments.\n\nHowever, we have to note that the imaging algorithm presented is based on ideal conditions without considering motion errors, which cannot be avoided in practice . Motion error analysis and compensation algorithms deserve further studying.\n\n#### Appendix\n\nHere, we give the detailed formations of some parameters. Wu et al. deduced an exact expression for tandem bistatic SAR , which is given aswhere\n\nSubstituting it into (4) and making Taylor series expansion up to the cubic term with respect to , the signal will come to (5). The detailed expressions of , , , and are\n\nIn (A.3)\n\nAs can be seen, the expressions seem rather complicated due to the complex formation of the half bistatic angle; however, they will turn into the familiar ones under the monostatic condition when and .\n\n#### Competing Interests\n\nThe authors declare that they have no competing interests.\n\n#### Acknowledgments\n\nThis work was supported by the Natural Science Foundation of China (Grant 61222108) and the Fundamental Research Funds for the Central Universities (Grant GK201603089).\n\n1. M. Antoniou, M. Cherniakov, and H. Ma, “Space-surface bistatic synthetic aperture radar with navigation satellite transmissions: a review,” Science China Information Sciences, vol. 58, no. 6, pp. 1–20, 2015. View at: Publisher Site | Google Scholar\n2. S. Chen, M. Xing, S. Zhou, L. Zhang, and Z. Bao, “Focusing of tandem bistatic SAR data using the chirp-scaling algorithm Emerging radar techniques,” EURASIP Journal on Advances in Signal Processing, vol. 2013, no. 1, article 38, 2013. View at: Publisher Site | Google Scholar\n3. S. Cherouat, F. Soltani, F. Schmitt, and F. Daout, “Using fractal dimension to target detection in bistatic SAR data,” Signal, Image and Video Processing, vol. 9, no. 2, pp. 365–371, 2013. View at: Publisher Site | Google Scholar\n4. Q. Zhang, W. Chang, and X. Li, “An integrative synchronization and imaging approach for bistatic spaceborne/stratospheric SAR with a fixed receiver,” Eurasip Journal on Advances in Signal Processing, vol. 2013, no. 1, article 165, 2013. View at: Publisher Site | Google Scholar\n5. M. Weiß, “Time and frequency synchronization aspects for bistatic SAR systems,” in Proceedings of the European Conference on Synthetic Aperture Radar (EUSAR '04), pp. 395–399, Ulm, Germany, 2004. View at: Google Scholar\n6. G. Krieger and A. Moreira, “Spaceborne bi- and multistatic SAR: potentials and challenges,” IET Radar, Sonar and Navigation, vol. 153, no. 3, pp. 184–198, 2006. View at: Publisher Site | Google Scholar\n7. B. Barber, “Theory of digital imaging from orbit synthetic aperture radar,” International Journal of Remote Sensing, vol. 6, no. 6, pp. 1009–1057, 1985. View at: Publisher Site | Google Scholar\n8. M. Rodriguez-Cassola, P. Prats, G. Krieger, and A. Moreira, “Efficient time-domain image formation with precise topography accommodation for general bistatic SAR configurations,” IEEE Transactions on Aerospace and Electronic Systems, vol. 47, no. 4, pp. 2949–2966, 2011. View at: Publisher Site | Google Scholar\n9. Y. F. Shao, R. Wang, Y. K. Deng et al., “Fast backprojection algorithm for bistatic SAR imaging,” IEEE Geoscience and Remote Sensing Letters, vol. 10, no. 5, pp. 1080–1084, 2013. View at: Publisher Site | Google Scholar\n10. V. Giroux, H. Cantalloube, and F. Daout, “An Omega-K algorithm for SAR bistatic systems,” in Proceedings of the IEEE International Geoscience and Remote Sensing Symposium (IGARSS '05), pp. 1060–1063, Seoul, South Korea, July 2005. View at: Publisher Site | Google Scholar\n11. I. Walterscheid, J. H. G. Ender, A. R. Brenner, and O. Loffeld, “Bistatic SAR processing and experiments,” IEEE Transactions on Geoscience and Remote Sensing, vol. 44, no. 10, pp. 2710–2717, 2006. View at: Publisher Site | Google Scholar\n12. R. Bamler, F. Meyer, and W. Liebhart, “Processing of bistatic SAR data from quasi-stationary configurations,” IEEE Transactions on Geoscience and Remote Sensing, vol. 45, no. 11, pp. 3350–3358, 2007. View at: Publisher Site | Google Scholar\n13. Y. L. Neo, F. Wong, and I. G. Cumming, “A two-dimensional spectrum for bistatic SAR processing using series reversion,” IEEE Geoscience and Remote Sensing Letters, vol. 4, no. 1, pp. 93–96, 2007. View at: Publisher Site | Google Scholar\n14. Y. L. Neo, F. Wong, and I. G. Cumming, “A comparison of point target spectra derived for bistatic SAR processing,” IEEE Transaction on Geoscience and Remote Sensing, vol. 46, no. 9, pp. 93–96, 2008. View at: Google Scholar\n15. R. Wang, Y. K. Deng, O. Loffeld et al., “Processing the azimuth-variant bistatic SAR data by using monostatic imaging algorithms based on two-dimensional principle of stationary phase,” IEEE Transactions on Geoscience and Remote Sensing, vol. 49, no. 10, pp. 3504–3520, 2011. View at: Publisher Site | Google Scholar\n16. D. D' Aria, A. M. Guarnieri, and F. Rocca, “Focusing bistatic synthetic aperture radar using dip move out,” IEEE Transactions on Geoscience and Remote Sensing, vol. 42, no. 7, pp. 1362–1376, 2004. View at: Publisher Site | Google Scholar\n17. O. Loffeld, H. Nies, V. Peters, and S. Knedlik, “Models and useful relations for bistatic SAR processing,” IEEE Transactions on Geoscience and Remote Sensing, vol. 42, no. 10, pp. 2031–2038, 2004. View at: Publisher Site | Google Scholar\n18. M. Rodriguez-Cassola, P. Prats, D. Schulze et al., “First bistatic spaceborne SAR experiments with TanDEM-X,” IEEE Geoscience and Remote Sensing Letters, vol. 9, no. 1, pp. 33–37, 2012. View at: Publisher Site | Google Scholar\n19. A. Jäggi, O. Montenbruck, Y. Moon et al., “Inter-agency comparison of TanDEM-X baseline solutions,” Advances in Space Research, vol. 50, no. 2, pp. 260–271, 2012. View at: Publisher Site | Google Scholar\n20. Q. Wu, M. Xing, H. Shi, X. Hu, and Z. Bao, “Exact analytical two-dimensional spectrum for bistatic synthetic aperture radar in tandem configuration,” IET Radar, Sonar and Navigation, vol. 5, no. 3, pp. 349–360, 2011. View at: Publisher Site | Google Scholar\n21. Q. Wu, Y. Liang, M. Xing, C. Qiu, Z. Bao, and T.-S. Yeo, “Focusing of tandem bistatic-configuration data with range migration algorithm,” IEEE Geoscience and Remote Sensing Letters, vol. 8, no. 1, pp. 88–92, 2011. View at: Publisher Site | Google Scholar\n22. Z. Zhenhua, X. Mengdao, D. Jinshan, and B. Zheng, “Focusing parallel bistatic SAR data using the analytic transfer function in the wavenumber domain,” IEEE Transactions on Geoscience and Remote Sensing, vol. 45, no. 11, pp. 3633–3645, 2007. View at: Publisher Site | Google Scholar\n23. J. Mittermayer, A. Moreira, and O. Loffeld, “Spotlight SAR data processing using the frequency scaling algorithm,” IEEE Transactions on Geoscience and Remote Sensing, vol. 37, no. 5, pp. 2198–2214, 1999. View at: Publisher Site | Google Scholar\n24. W. Davidson, I. G. Cumming, and M. R. Ito, “A chirp scaling approach for processing squint model SAR data,” IEEE Transaction on Aerospace and Electronic Systems, vol. 32, no. 1, pp. 121–133, 1996. View at: Publisher Site | Google Scholar\n25. B. D. Rigling and R. L. Moses, “Motion measurement errors and autofocus in bistatic SAR,” IEEE Transactions on Image Processing, vol. 15, no. 4, pp. 1008–1016, 2006. View at: Publisher Site | Google Scholar" ]

[ null ]

[ "", null, "GFG App\nOpen App", null, "Browser\nContinue\n\n# LocalDate until(Temporal,TemporalUnit) Method in Java with Examples\n\nuntil() method of the LocalDate class used to calculate the amount of time between two LocalDate objects using TemporalUnit. The start and end points are this and the specified LocalDate passed as a parameter. The result will be negative if the end is before the start. The calculation returns a whole number, representing the number of complete units between the two LocalDate. This instance is immutable and unaffected by this method call.\n\nSyntax:\n\n```public long until(Temporal endExclusive, TemporalUnit unit)\n```\n\nParameters: This method accepts two parameters endExclusive which is the end date, exclusive, which is converted to a LocalDate and unit which is the unit to measure the amount.\n\nReturn value: This method returns the amount of time between this LocalDate and the end LocalDate.\n\nException:This method throws following Exceptions:\n\n• DateTimeException – if the amount cannot be calculated, or the ending temporal cannot be converted to a LocalDate.\n• UnsupportedTemporalTypeException – if the unit is not supported.\n• ArithmeticException – if numeric overflow occurs.\n\nBelow programs illustrate the until() method:\nProgram 1:\n\n `// Java program to demonstrate ` `// LocalDate.until() method ` ` `  `import` `java.time.*; ` `import` `java.time.temporal.*; ` ` `  `public` `class` `GFG { ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``// create LocalDate objects ` `        ``LocalDate l1 ` `            ``= LocalDate ` `                  ``.parse(``\"2018-12-06\"``); ` ` `  `        ``LocalDate l2 ` `            ``= LocalDate ` `                  ``.parse(``\"2018-10-25\"``); ` ` `  `        ``// apply until the method of LocalDate class ` `        ``long` `result ` `            ``= l2.until(l1, ` `                       ``ChronoUnit.DAYS); ` ` `  `        ``// print results ` `        ``System.out.println(``\"Result in DAYS: \"` `                           ``+ result); ` `    ``} ` `} `\n\nOutput:\n\n```Result in DAYS: 42\n```\n\nProgram 2:\n\n `// Java program to demonstrate ` `// LocalDate.until() method ` ` `  `import` `java.time.*; ` `import` `java.time.temporal.*; ` ` `  `public` `class` `GFG { ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``// create LocalDate objects ` `        ``LocalDate l1 ` `            ``= LocalDate ` `                  ``.parse(``\"2018-12-06\"``); ` ` `  `        ``LocalDate l2 ` `            ``= LocalDate ` `                  ``.parse(``\"2018-10-25\"``); ` ` `  `        ``// apply until() ` `        ``long` `result ` `            ``= l2.until(l1, ` `                       ``ChronoUnit.MONTHS); ` ` `  `        ``// print results ` `        ``System.out.println(``\"Result in MONTHS: \"` `                           ``+ result); ` `    ``} ` `} `\n\nOutput:\n\n```Result in MONTHS: 1\n```\n\nMy Personal Notes arrow_drop_up" ]

[ null, "https://media.geeksforgeeks.org/gfg-gg-logo.svg", null, "https://media.geeksforgeeks.org/auth-dashboard-uploads/web-2.png", null ]

[ "# An Etymological Dictionary of Astronomy and AstrophysicsEnglish-French-Persian\n\n## فرهنگ ریشه شناختی اخترشناسی-اخترفیزیک\n\n### M. Heydari-Malayeri    -    Paris Observatory\n\nHomepage\n\nNumber of Results: 12 Search : value\n absolute value   ارزش ِ اوست   arzeš-e avastFr.: valeur absolue   For any → real number a, the non-negative value of a without regard to its sign; denoted by |a|. Same as → modulus. The absolute value of a is always either → positive or → zero, but never negative. The absolute value of a number may be thought of as its → distance from zero. The following rules hold: |ab| = |a||b| |a + b|  ≤  |a| + |b| |a - b|  ≥  |a| - |b| For a> 0, |x|  ≤  a if and only if -a  ≤  x  ≤  a.→ absolute; → value. discrete value   ارزش ِ گسسته   arzeš-e gosastéFr.: valeur discrète   A quantity that has certain magnitudes and does not represent a → continuous variable.→ discrete; → value. eigenvalue   ویژ ارزه   viž-arzéFr.: valeur propre   1) Math.: The one of the → scalars λ such that T(v) = λv, where T is a linear → operator on a → vector space, and v is an → eigenvector. 2) Quantum mechanics: The specified values of → quantized energy for which the → Schrodinger equation is soluble, subject to the appropriate → boundary conditions.→ eigenfunction; → value. expected value   ارزش ِ بیوسیده   arzeš- bayusidéFr.: valeur espérée   Statistics: Same as → mathematical expectation, → expectation.→ expectation; → value. half-value layer (HVL)   لایه‌ی ِ نیم-تنکش   lâye-ye nim-tonokešFr.: couche de demi-atténuation   The thickness of material required to reduce the intensity of an → X-ray beam to one half of its initial value. The HVL is an indirect measure of the photon energies of a beam.→ half; → value; → layer; → attenuation. mean value theorem   فربین ِ ارزش ِ میانگین   farbin-e arzeš-e miyânginFr.: théorème des accroissements finis   1) If f(x) is a continuous function on the interval from a to b, then: ∫ f(x) dx = f(c)(b - a) (summed from a to b) for at least one point in that interval. 2) More generally, If f(x) and g(x) are continuous functions on the interval from a to b and g(x)≥ 0, then: ∫ f(x)g(x) dx = f(c) ∫ g(x) dx (both integrals summed from a to b).→ mean; → value; → theorem. nominal value   ارزش ِ نامنال   arzeš-e nâmenâlFr.: valeur nominale   The assigned, specified, or intended value of a quantity.→ nominal; → value. place-value notation   نمادگان ِ جا-ارزشی   nemâdgân-e jâ-arezešiFr.: notation positionnelle   A mathematical notation system in which the → numerals get different values depending on their position relative to the other numerals. Same as → positional notation and → positional number system.→ place; → value; → notation. root-mean-square value   ارزش ِ ریشه‌ی ِ چاروشی ِ میانگین   arzeš-e riše-ye câruši-ye miyânginFr.: écart quadratique moyen, écart type   Statistics: The square root of the arithmetic mean of the squares of the deviation of observed values from their arithmetic mean.→ root; → mean; → square; → deviation. standard values   ارزش‌های ِ استانده   arzešhâ-ye estândéFr.: valeurs standard   Photometric values of selected stars in a standard system.→ standard; → value. truth value   ارزش ِ راستینی   arzeš-e râstiniFr.: valeur de vérité   The quality of a logical → proposition (or a formal → symbol) which describes the relation of a proposition to → truth. The traditional → formal logic admits only two contradictory values, → true or → false. In → symbolic logic, more specifically in → polyvalent logics, other truth values are used (such as possible, impossible, undetermined, probable, random, etc.).→ truth; → value. value   ارزش   arzeš (#)Fr.: valeur   Math.: Magnitude; quantity; a numerical quantity assigned to a mathematical symbol.M.E., from O.Fr. value \"worth, value,\" noun use of feminine p.p. of valoir \"be worth,\" from L. valere \"be strong, be well, be of value.\"Arzeš, verbal noun of arzidan \"to be worth,\" arzân \"worthy; of small value, cheap,\" arj \"esteem, honour, price, worth;\" Mid.Pers. arz \"value, worth,\" arzidan \"be worth,\" arzân \"valuable;\" Av. arəjaiti \"is worth,\" arəja- \"valuable,\" arəg- \"to be worth;\" cf. Skt. arh- \"to be worth, to earn,\" árhant- \"worthy person;\" Gk. alphanein \"to bring in as profit,\" alphein \"to ear, obtain;\" Lith. algà \"salary, pay;\" PIE base *algwh- \"to earn; price, value.\"" ]

[ null ]

[ "# Testing Distributed Systems for Linearizability\n\nDistributed systems are challenging to implement correctly because they must handle concurrency and failure. Networks can delay, duplicate, reorder, and drop packets, and machines can fail at any time. Even when designs are proven correct on paper, it is difficult to avoid subtle bugs in implementations.\n\nUnless we want to use formal methods1, we have to test systems if we want assurance that implementations are correct. Testing distributed systems is challenging, too. Concurrency and nondeterminism make it difficult to catch bugs in tests, especially when the most subtle bugs surface only under scenarios that are uncommon in regular operation, such as simultaneous machine failure or extreme network delays.\n\n# Correctness\n\nBefore we can discuss testing distributed systems for correctness, we need to define what we mean by “correct”. Even for seemingly simple systems, specifying exactly how the system is supposed to behave is an involved process2.\n\nConsider a simple key-value store, similar to etcd, that maps strings to strings and supports two operations: Put(key, value) and Get(key). First, we consider how it behaves in the sequential case.\n\n## Sequential Specifications\n\nWe probably have a good intuitive understanding of how a key-value store is supposed to behave under sequential operation: Get operations must reflect the result of applying all previous Put operations. For example, we could run a Put(\"x\", \"y\") and then a subsequent Get(\"x\") should return \"y\". If the operation returned, say, a \"z\", that would be incorrect.\n\nMore formal than an English-language description, we can write a specification for our key-value store as executable code:\n\nclass KVStore:\ndef __init__(self):\nself._data = {}\n\ndef put(self, key, value):\nself._data[key] = value\n\ndef get(self, key):\nreturn self._data.get(key, \"\")\n\n\nThe code is short, but it nails down all the important details: the start state, how the internal state is modified as a result of operations, and what values are returned as a result of calls on the key-value store. The spec solidifies some details like what happens when Get() is called on a nonexistent key, but in general, it lines up with our intuitive definition of a key-value store.\n\n## Linearizability\n\nNext, we consider how our key-value store can behave under concurrent operation. Note that the sequential specification does not tell us what happens under concurrent operation. For example, the sequential spec doesn’t say how our key-value store is allowed to behave in this scenario:", null, "It’s not immediately obvious what value the Get(\"x\") operation should be allowed to return. Intuitively, we might say that because the Get(\"x\") is concurrent with the Put(\"x\", \"y\") and Put(\"x\", \"z\"), it can return either value or even \"\". If we had a situation where another client executed a Get(\"x\") much later, we might say that the operation must return \"z\", because that was the value written by the last write, and the last write operation was not concurrent with any other writes.\n\nWe formally specify correctness for concurrent operations based on a sequential specification using a consistency model known as linearizability. In a linearizable system, every operation appears to execute atomically and instantaneously at some point between the invocation and response. There are other consistency models besides linearizability, but many distributed systems provide linearizable behavior: linearizability is a strong consistency model, so it’s relatively easy to build other systems on top of linearizable systems.\n\nConsider an example history with invocations and return values of operations on a key-value store:", null, "This history is linearizable. We can show this by explicitly finding linearization points for all operations (drawn in blue below). The induced sequential history, Put(\"x\", \"0\"), Get(\"x\") -> \"0\", Put(\"x\", \"1\"), Get(\"x\") -> \"1\", is a correct history with respect to the sequential specification.", null, "In contrast, this history is not linearizable:", null, "There is no linearization of this history with respect to the sequential specification: there is no way to assign linearization points to operations in this history. We could start assigning linearization points to the operations from clients 1, 2, and 3, but then there would be no way to assign a linearization point for client 4: it would be observing a stale value. Similarly, we could start assigning linearization points to the operations from clients 1, 2, and 4, but then the linearization point of client 2’s operation would be after the start of client 4’s operation, and then we wouldn’t be able to assign a linearization point for client 3: it could legally only read a value of \"\" or \"0\".\n\n# Testing\n\nWith a solid definition of correctness, we can think about how to test distributed systems. The general approach is to test for correct operation while randomly injecting faults such as machine failures and network partitions. We could even simulate the entire network so it’s possible to do things like cause extremely long network delays. Because tests are randomized, we would want to run them a bunch of times to gain assurance that a system implementation is correct.\n\nHow do we actually test for correct operation? With the simplest software, we test it using input-output cases like assert(expected_output == f(input)). We could use a similar approach with distributed systems. For example, with our key-value store, we could have the following test where multiple clients are executing operations on the key-value store in parallel:\n\nfor client_id = 0..10 {\nfor i = 0..1000 {\nvalue = rand()\nkvstore.put(client_id, value)\nassert(kvstore.get(client_id) == value)\n}\n}\n}\n\n\nIt is certainly the case that if the above test fails, then the key-value store is not linearizable. However, this test is not that thorough: there are non-linearizable key-value stores that would always pass this test.\n\n## Linearizability\n\nA better test would be to have parallel clients run completely random operations: e.g. repeatedly calling kvstore.put(rand(), rand()) and kvstore.get(rand()), perhaps limited to a small set of keys to increase contention. But in this case, how would we determine what is “correct” operation? With the simpler test, we had each client operating on a separate key, so we could always predict exactly what the output had to be.\n\nWhen clients are operating concurrently on the same set of keys, things get more complicated: we can’t predict what the output of every operation has to be because there isn’t only one right answer. So we have to take an alternative approach: we can test for correctness by recording an entire history of operations on the system and then checking if the history is linearizable with respect to the sequential specification.\n\n### Linearizability Checking\n\nA linearizability checker takes as input a sequential specification and a concurrent history, and it runs a decision procedure to check whether the history is linearizable with respect to the spec.\n\n#### NP-Completeness\n\nUnfortunately, linearizability checking is NP-complete. The proof is actually quite simple: we can show that linearizability checking is in NP, and we can show that an NP-hard problem can be reduced to linearizability checking. Clearly, linearizability checking is in NP: given a linearization, i.e. the linearization points of all operations, we can check in polynomial time if it is a valid linearization with respect to the sequential spec.\n\nTo show that linearizability checking is NP-hard, we can reduce the subset sum problem to linearizability checking. Recall that in the subset sum problem, we are given a set $S = \\{s_1, s_2, \\ldots, s_n\\}$ of non-negative integers and a target value $t$, and we have to determine whether there exists a subset of $S$ that sums to $t$. We can reduce this problem to linearizability checking as follows. Consider the sequential spec:\n\nclass Adder:\ndef __init__(self):\nself._total = 0\n\nself._total += value\n\ndef get(self):\nreturn self._total\n\n\nAnd consider this history:", null, "This history is linearizable if and only if the answer to the subset sum problem is “yes”. If the history is linearizable, then we can take all the operations Add(s_i) that have linearization points before that of the Get() operation, and those correspond to elements $s_i$ in a subset whose sum is $t$. If the set does have a subset that sums to $t$, then we can construct a linearization by having the operations Add(s_i) corresponding to the elements $s_i$ in the subset take place before the Get() operation and having the rest of the operations take place after the Get() operation.\n\n### Implementation\n\nEven though linearizability checking is NP-complete, in practice, it can work pretty well on small histories. Implementations of linearizability checkers take an executable specification along with a history, and they run a search procedure to try to construct a linearization, using tricks to constrain the size of the search space.\n\nThere are existing linearizability checkers like Knossos, which is used in the Jepsen test system. Unfortunately, when trying to test an implementation of a distributed key-value store that I had written, I couldn’t get Knossos to check my histories. It seemed to work okay on histories with a couple concurrent clients, with about a hundred history events in total, but in my tests, I had tens of clients generating histories of thousands of events.\n\nTo be able to test my key-value store, I wrote Porcupine, a fast linearizability checker implemented in Go. Porcupine checks if histories are linearizable with respect to executable specifications written in Go. Empirically, Porcupine is thousands of times faster than Knossos. I was able to use it to test my key-value store because it is capable of checking histories of thousands of events in a couple seconds.\n\n# Effectiveness\n\nTesting linearizable distributed systems using fault injection along with linearizability checking is an effective approach.\n\nTo compare ad-hoc testing with linearizability checking using Porcupine, I tried testing my distributed key-value store using the two approaches. I tried introducing different kinds of design bugs into the implementation of the key-value store, such as modifications that would result in stale reads, and I checked to see which tests failed. The ad-hoc tests caught some of the most egregious bugs, but the tests were incapable of catching the more subtle bugs. In contrast, I couldn’t introduce a single correctness bug that the linearizability test couldn’t catch.\n\n1. Formal methods can provide strong guarantees about the correctness of distributed systems. For example, the UW PLSE research group has recently verified an implementation of the Raft consensus protocol using the Coq proof assistant. Unfortunately, verification requires specialized knowledge, and verifying realistic systems involves huge effort. Perhaps one day systems used in the real world will be proven correct, but for now, production systems are tested but not verified.\n\n2. Ideally, all production systems would have formal specifications. Some systems that are being used in the real world today do have formal specs: for example, Raft has a formal spec written in TLA+. But unfortunately, the majority of real-world systems do not have formal specs." ]

[ null, "https://www.anishathalye.com/media/2017/06/04/operation-1.svg", null, "https://www.anishathalye.com/media/2017/06/04/history-1.svg", null, "https://www.anishathalye.com/media/2017/06/04/history-1-linearization.svg", null, "https://www.anishathalye.com/media/2017/06/04/history-2.svg", null, "https://www.anishathalye.com/media/2017/06/04/subset-sum.svg", null ]

[ "# Is there a general algorithm to fill holes in terms of the Calculus of Constructions?\n\nSuppose that you extend the Calculus of Constructions with \"holes\" - i.e., incomplete pieces of code that you didn't fill yet. I wonder if there is an algorithm to fill those roles automatically. For example (using Morte's syntax):\n\n### Case A:\n\nλ (pred : ?)\n-> λ (Nat : *)\n-> λ (Succ : Nat -> Nat)\n-> λ (Zero : Nat)\n-> (Succ (pred Nat Succ Zero))\n\n\nOn this situation, a type inference algorithm can identify that ? can obviously only be ∀ (Nat : *) -> (Nat -> Nat) -> Nat -> Nat, because pred receives Nat : *, Succ : Nat -> Nat, Zero : Nat, and must return Nat, because it is the first argument of Succ.\n\n### Case B:\n\n(Id ? 4)\n\n\nWhere 4 is λ-encoded and Id is the identity function (i.e., ∀ (t:*) -> λ (x:t) -> x). On that situation, ´?´ is again clearly ∀ (N:*) -> (N -> N) -> N -> N, because that is the type of 4.\n\n### Case C:\n\n(Id (Equals Nat 7 (add 3 ?)) (Refl 7))\n\n\nHere,Equals and Refl are defined in a similar fashion to Idris. ? can obviously only be 4, but how do you figure that out? One way would be using the fact that ? : Nat, and Nat is a type which we know how to enumerate, so we can just try all Nats til it typechecks. That can be done for any enumerable type.\n\n### Case D:\n\n(Id (Equal Nat 10 (MulPair ?)) 10)\n\n\nHere, ? can only be of type Pair Nat; it has only more than one valid answer, though: it can be (Pair 10 1), (Pair 2 5), (Pair 5 2) and (Pair 1 10).\n\n### Case E:\n\n(Id (Equal Nat 7 (Mul 2 ?)) 7)\n\n\nHere, there is no valid answer, since 7 isn't a multiple of 2.\n\nAll those examples made me notice that we can make a general algorithm that identifies some known patterns and gives an answer by handpicking a specific algorithm (type inference, brute-force, and so on), kinda like Wolfram Alpha figures out the right strategy to solve an Integral. But that sounds like an engineering/hardcoded approach. Is there a principled way to solve this problem? Is there any research study/area on it?\n\nThere is certainly a lot of research into this problem! It often goes by the name of elaboration. It is an undecidable problem in general, as you may have guessed. The \"holes\" are often called meta-variables or unification variables.\n\nAs I explain a bit in this answer, the problem reduces to higher order unification, on which several people have written whole PhD dissertations.\n\nAs you note in your examples, some cases are somewhat easy, and can be solved by the application of simple rules, whereas some seem significantly more difficult, and have more of a \"theorem proving\" feel to them.\n\nA third possible case is a \"type class\" type problem, where ? represents some kind of structure, such as a group or field structure, as in\n\nmul ? 2 3\n\n\nwith mul : forall G:Group, G.carrier -> G.carrier -> G.carrier or some variant. Here we need to find a G such that G.carrier == nat.\n\nIn general, you want to have 3 different \"regimes\" for each type of problem, the simple unification, theorem proving, and type class resolution problems respectively.\n\nWe explain this a bit in the following paper:\n\nElaboration in Dependent Type Theory, de Moura, Avigad, Kong & Roux.\n\nYou might want to look at the references of that paper for more info.\n\nI've you've got a strong stomach, here is the open-source for elaboration in Lean.\n\nHere is a wiki post that describes the interface to the elaborator in Idris.\n\n• Those are the words I wanted to hear! Thanks for all those links, references and keywords, you gave me a lot to do now. Are there available tools that I can use to complete Morte programs today? Of course not necessarily Morte but something close enough to extract Morte programs. – MaiaVictor Dec 15 '16 at 16:04\n• Every theorem prover and type checker for a dependently typed system (Idris, Agda, Coq, Lean) will have such a solver deep inside their guts. They tend to be very program specific though, so I'm not optimistic you can use them for your own purposes without heavy modification. – cody Dec 15 '16 at 22:41" ]

[ null ]

[ "## Conversion formula\n\nThe conversion factor from days to minutes is 1440, which means that 1 day is equal to 1440 minutes:\n\n1 d = 1440 min\n\nTo convert 660 days into minutes we have to multiply 660 by the conversion factor in order to get the time amount from days to minutes. We can also form a simple proportion to calculate the result:\n\n1 d → 1440 min\n\n660 d → T(min)\n\nSolve the above proportion to obtain the time T in minutes:\n\nT(min) = 660 d × 1440 min\n\nT(min) = 950400 min\n\nThe final result is:\n\n660 d → 950400 min\n\nWe conclude that 660 days is equivalent to 950400 minutes:\n\n660 days = 950400 minutes\n\n## Alternative conversion\n\nWe can also convert by utilizing the inverse value of the conversion factor. In this case 1 minute is equal to 1.0521885521886E-6 × 660 days.\n\nAnother way is saying that 660 days is equal to 1 ÷ 1.0521885521886E-6 minutes.\n\n## Approximate result\n\nFor practical purposes we can round our final result to an approximate numerical value. We can say that six hundred sixty days is approximately nine hundred fifty thousand four hundred minutes:\n\n660 d ≅ 950400 min\n\nAn alternative is also that one minute is approximately zero times six hundred sixty days.\n\n## Conversion table\n\n### days to minutes chart\n\nFor quick reference purposes, below is the conversion table you can use to convert from days to minutes\n\ndays (d) minutes (min)\n661 days 951840 minutes\n662 days 953280 minutes\n663 days 954720 minutes\n664 days 956160 minutes\n665 days 957600 minutes\n666 days 959040 minutes\n667 days 960480 minutes\n668 days 961920 minutes\n669 days 963360 minutes\n670 days 964800 minutes" ]

[ null ]

[ "", null, "", null, "", null, "", null, "", null, "", null, "", null, "Re: Help with solving ODE\n\n• To: mathgroup at smc.vnet.net\n• Subject: [mg81811] Re: [mg81772] Help with solving ODE\n• From: Murray Eisenberg <murray at math.umass.edu>\n• Date: Thu, 4 Oct 2007 04:19:03 -0400 (EDT)\n• Organization: Mathematics & Statistics, Univ. of Mass./Amherst\n• References: <[email protected]>\n\n```Did you even TRY to read the documentation about solving differential\nequations in Mathematica? And learn the most basic things about syntax\nand the function DSolve to solve differential equations?\n\nI'll use i instead of I since the latter is the complex number, and c\ninstead of D since the latter stands for derivative, in Mathematica.\n\nYou obtain the solution in terms of the constants from:\n\nsoln=First@DSolve[{i y''[t]+k y'[t]==-c/a^2,y==0,y'==0},y[t],t]\n{y[t] ->\n-((c*(i - E^((k*t)/i)*i + E^((k*t)/i)*k*t))/(a^2*E^((k*t)/i)*k^2))}\n\nThe form of the solution is that of a replacement rule. If you want\njust the solution itself, as a function of t:\n\ny[t] /. soln\n-((c*(i - E^((k*t)/i)*i + E^((k*t)/i)*k*t))/(a^2*E^((k*t)/i)*k^2))\n\nThis is all still in terms of the constants. To get it with the\nnumerical values of the constants, just replace them with their values:\n\ny[t]/.soln/.{i->13138117.34, k->724.68,\nc->2*6.67*10^-8*158100*729.8*93.09, a->22.10 } // Expand\n-73.39232171339471/E^(0.00005515858788942739*t) +\n73.39232171339471*E^(0.*t) - 0.004048216827637412*E^(0.*t)*t\n\nFor each input above, I actually applied the function InputForm to the\ncorresponding output in order to obtain a one-dimensional format for\npasting into a plain text e-mail message. In reality, in a Mathematica\nnotebook you would not do that so as to allow two-dimensional display\nwith fractions and exponents.\n\nPioneer1 wrote:\n> Hi,\n>\n> Can anyone help solve this linearized differential equation:\n>\n> Iy'' + ky' = 2GMmd/a^2\n>\n> Primes are time derivates of y (=theta=excursion angle). Is it\n> possible to solve this for the initial conditions y(0)=0 and y'(0)=0?\n>\n> I got the solution at sci.math for the non-linear version and I want\n>\n>\n> Further information is also available at sci.physics.research\n>\n>\n> Parameters are:\n>\n>> y = theta = excursion angle in radians\n>> A = I = moment of inertia = 13,138,117.34 g cm^2\n>> B = R = damping = for now I assume this to be zero\n>> C = k = torsion constant = 724.68 g cm^2 sec^-2\n>> d = moment arm = 93.09 cm\n>> D = 2GMmd = 2 * 6.67*10^-8 * 158100 * 729.8 * 93.09 = 1432.82\n>> a = distance between weights = 22.10 cm\n>\n> I would truly appreciate help with this. Thanksi\n>\n>\n\n--\nMurray Eisenberg murray at math.umass.edu\nMathematics & Statistics Dept.\nLederle Graduate Research Tower phone 413 549-1020 (H)\nUniversity of Massachusetts 413 545-2859 (W)\n710 North Pleasant Street fax 413 545-1801\nAmherst, MA 01003-9305\n\n```\n\n• Prev by Date: problem with contourplot\n• Next by Date: Manipulate+Plot showing no output\n• Previous by thread: Help with solving ODE\n• Next by thread: Re: Help with solving ODE" ]

[ null, "http://forums.wolfram.com/mathgroup/images/head_mathgroup.gif", null, "http://forums.wolfram.com/mathgroup/images/head_archive.gif", null, "http://forums.wolfram.com/mathgroup/images/numbers/2.gif", null, "http://forums.wolfram.com/mathgroup/images/numbers/0.gif", null, "http://forums.wolfram.com/mathgroup/images/numbers/0.gif", null, "http://forums.wolfram.com/mathgroup/images/numbers/7.gif", null, "http://forums.wolfram.com/mathgroup/images/search_archive.gif", null ]

[ "Was there physics science before invention of calculus?\n\nIs there a part of physics that there is no calculus in it?\n\n• One could do all of physics without calculus, but it would be incredibly tedious. A look at old physics books, especially Newton's \"Principia\" can easily convince you of that. A somewhat easier read that demonstrates the same problem would be Copernicus' \"De revolutionibus orbium coelestium\" and Kepler's works. In essence, you would \"re-invent the calculus wheel\" all the time. Jul 6 '16 at 5:26\n• What do you think? Why do you think physics might not have existed before then? Jul 6 '16 at 5:32\n• @sammygerbil Because I think physics science has been created by observation of phenomenons (variations) and without calculus how can we talk about variations? Jul 6 '16 at 5:35\n• The Greeks had some real breakthroughs in physics and they also made some doozies... all without calculus. Jul 6 '16 at 6:01\n• Is this on topic for us? I thought recently we have considered pure history questions to be off topic and sent them to History of Science and Mathematics. Jul 6 '16 at 7:55\n\nInfinitesimal calculus was first formulated by Isaac Newton and Gottfried Leibniz in the mid-17th century. By that time, a number of qualitative and quantitative physical laws had been formulated. Here are some examples of the quantitative laws:\n\nDynamics\n\n• Laws of planetary motion (Kepler)\n• Motion of falling bodies, pendula, projectiles (Galileo, Torricelli)\n\nOptics\n\n• Inverse-square law for light intensity (Kepler)\n• Law governing the angle of refraction (Snell, Descartes)\n\nHydrostatics and Hydrodynamics\n\n• Law of hydrostatic pressure (Torricelli)\n• Rate of flow through a small hole (Torricelli)\n\nMaterial Science\n\n• Square-cube law governing strength of structures under proportional scaling (Galileo)\n• You might include Torricelli's work on pressure, optics, fluids and projectile motion. Jul 7 '16 at 4:22\n\nNote: Following answer is just my humble opinion\n\nGalileo is the forefather of the modern physics. He has discovered law of inertia and law of acceleration. It may be worth noting that He was unaware of even very basic mathematics (like fractions). He had shown law of acceleration with the help the water clock and integer numbers.\n\nMoreover, Newton has verified his law of gravity (and motion) from the moon trajectory. These laws are in the form of equations, derived by Kepler for which data is taken by his predecessors. If Kepler and his predecessors have not done the Herculean task of mapping the planetary orbits it would be difficult for Newton to establish the validity of laws of motion.\n\nMathematics is definitely required for easier understanding of the laws of nature and that's why we are using more and more advanced mathematics in the physics. However, saying that there is no physics before the existence of one branch of mathematics, in my opinion it is outright disrespect for the hard work of our forefathers.\n\nI would also like to add that although mathematics comes before humans start to understand the physics but even today people use term \"Physical Arguments\" that essentially means that one is trying to explain the phenomena without mathematics or with minimal mathematics and mostly from logical arguments.\n\nThere are several examples of fields in physics which don't require calculus and were born far before its invention. For example:\n\n• Geometric Optics: some of the laws governing light propagation were formulated by ancient Greeks. Catoptrics (from the Greek κατοπτρικός, \"specular\") has been studied by Euclid (350 BC) and Hero of Alexandria (10-70 AD).\n• Statics: the study of the equilibrium of rigid bodies does not require calculus, but only geometry. Statics has been for obvious reasons (architecture) studied since forever: Archimedes wrote an essay on statics entitled On the Equilibrium of Planes, in which he establishes the law of the lever and calculates the center of gravity of various geometrical figures using only geometry. While it is true that some proofs contain a primitive form of calculus (for example the part regarding parabolic segments), many results are obtained using only Euclidean geometry.\n• Astronomy: Ancient Greeks used geometry to obtain remarkable results in the field of astronomy. Aristarchus of Samos wrote an essay entitled On the Sizes and Distances of the Sun and Moon and Erathostenes was able to calculate the circumference of the Earth.", null, "Other examples include hydrostatics and the study of projectile motion (ballistic).\n\nAlso, keep in mind that many ancient physical theories didn't make use of mathematics at all. Take for example Aristotelian physics. We may laugh at such a theory today, but we would be silly to do so: such a theory basically dominated the scientific world for two thousand years. For example, the aristotelian theory of projectile motion (the Theory of Impetus) came under slight criticism only during the Middle Ages (!) and we have to wait first Galilei and then Newton (Philosophiæ Naturalis Principia Mathematica was first published in 1687) for a satisfactory theory of projectile motion.\n\n• Thank you for your attention and time! I don't know what other people do, but I personally never laugh at them. I always respect to the past efforts. BTW, thank you because of useful historical information! I like that. Jul 12 '16 at 10:58\n\nThere's a lot of physics which is miles away from calculus but the problem is it's not accurate I think 80-90% of that is totally piece of junk and remaining is way more hard to understand without calculus but if you want you can do it like proof of kinamatical equation can be given simply by calculating area under those graphs but that's lot more hard than simply by using calculus" ]

[ null, "https://i.stack.imgur.com/e3L8p.jpg", null ]

[ "# Multiple Choice Questions (MCQ) on Capital Budgeting\n\nMultiple Choice Questions (MCQ) on Capital Budgeting\n\n1-The span of time within which the investment made for the project will be recovered by the net returns of the project is known as\n\n(A) Period of return\n\n(B) Payback period\n\n(C) Span of return\n\n(D) None of the above\n\n2-Projects with __________ are preferred\n\n(A) Lower payback period\n\n(B) Normal payback period\n\n(C) Higher payback period\n\n(D) Any of the above\n\n3-___________ on capital is called ‘Cost of capital’.\n\n(A) Lower expected return\n\n(B) Normally expected return\n\n(C) Higher expected return\n\n(D) None of the above\n\n4-The values of the future net incomes discounted by the cost of capital are called\n\n(A) Average capital cost\n\n(B) Discounted capital cost\n\n(C) Net capital cost\n\n(D) Net present values\n\n5-Under Net present value criterion, a project is approved if\n\n(A) Its net present value is positive\n\n(B) The funds are unlimited\n\n(C) Both (A) and (B)\n\n(D) None of the above\n\n6-The internal Rate of Return (IRR) criterion for project acceptance, under theoretically infinite funds is: accept all projects which have\n\n(A) IRR equal to the cost of capital\n\n(B) IRR greater than the cost of capital\n\n(C) IRR less than the cost of capital\n\n(D) None of the above\n\n7-Which of the following criterion is often preferred\n\n(A) Net present value\n\n(B) Profitability index\n\n(C) Internal Rate of Return\n\n(D) All of the above\n\n8-The project is accepted of\n\n(A) if the profitability index is equal to one\n\n(B) The funds are unlimited\n\n(C) If the profitability index is greater than one\n\n(D) Both (B) and (C)\n\n9-Where capital availability is unlimited and the projects are not mutually exclusive, for the same cost of capital, following criterion is used\n\n(A) Net present value\n\n(B) Internal Rate of Return\n\n(C) Profitability Index\n\n(D) Any of the above\n\n10-A project is accepted when\n\n(A) Net present value is greater than zero\n\n(B) Internal Rate of Return will be greater than cost of capital\n\n(C) Profitability index will be greater than unity\n\n(D) Any of the above\n\n11-With limited finance and a number of project proposals at hand, select that package of projects which has\n\n(A) The maximum net present value\n\n(B) Internal rate of return is greater than cost of capital\n\n(C) Profitability index is greater than unity\n\n(D) Any of the above\n\n12-A project may be regarded as high risk project when\n\n(A) It has smaller variance of outcome but a high initial investment\n\n(B) It has larger variance of outcome and high initial investment\n\n(C) It has smaller variance of outcome and a low initial investment\n\n(D) It has larger variance of outcome and low initial investment\n\n13-Following is (are) the method(s) for adjustment of risks" ]

[ null ]

[ "### what percent of 365 is 29 ?\n\nSolution: 29 is what percent the 365 is equal to (29 / 365) x 100 = 7.95%. therefore if girlfriend buy an item at \\$365 v \\$29 discounts, you will certainly pay \\$336 and also get 7.95% discount cashback rewards\n\nCalculate 29 is what percent that 365 v this calculator\n\nis What % of ? % price\n\n29 is what percent that 365 is identical to 29/365 together a percent\n\n### \\$29 out of 365 is what percent\n\nIn calculating 29% of a number, sales tax, credit transaction cards cash back bonus, interest, discounts, interest per annum, dollars, pounds, coupons,29% off, 29% the price or something, we use the formula above to find the answer. The equation for the calculation is very basic and direct. You can also compute other number values by using the calculator over and enter any kind of value you want to compute.percent disagreement to lb = 0 pound\n\nPercentage calculator tool deserve to be supplied by an initial entering the fractional worth you desire to calculate. For instance 5% the 20, i beg your pardon is the very same thing as portion x/100 * 20=5%. To find the value of x go into 5 in the very first box and 20 in the second box and also the price 1 will certainly be displayed in the an outcome box.\n\nYou are watching: 29 out of 39 as a percentage\n\nPercentage turn off calculator usual questions\n\n\\$29 out of 365 is what percent\n\nAnswer:The question \\$29 the end of 365 is 7.95%, which is the same as 29/365 as a percent. This deserve to be resolved using this calculator above\n\nHow do i job-related out Percentages there is no calculation ?\n\nAnswer: You occupational out Percentages by using the formula and tool above\n\nHow to calculation the % of a number ?\n\nAnswer: Using percentage formula and also equation above\n\nWhat % the a number is an additional number\n\nAnswer: use the calculator over to compute that\n\nHow to figure out and get 29% interest per annum\n\nAnswer: You work-related out 29% interest per annum by using straightforward interest formula of I=PxTxR/100. Whereby r is the price of 29% , P=Principal, T=Time\n\nFormula and also equation for % of miscellaneous or totality numbers\n\nAnswer: usage the tool over to compute that\n\nWhat is 29 sales tax formula\n\nAnswer: 29 sales taxation is calculated by obtaining the 29% of her sales as tax\n\nHow to acquire gross profit or weight loss of % calculation\n\nAnswer: usage the tool above to compute that\n\n7.95% of 365 is what\n\nAnswer: To uncover out 7.95% that 365 is what dollars or pounds, just use the calculator to gain the solution\n\nHow to calculation 29 the a price\n\nAnswer: calculation 29 that a price by start the price ~ above the calculator with your value to get the %\n\nHow to calculate 29% pounds discounts\n\nAnswer: calculate 29% pounds discounts by start the discounts price top top the calculator through your value to acquire the discounts and also gets cash earlier bonus top top your credit transaction card\n\nwhat percent the 365 is 29 dollars\n\nAnswer: calculation percent that 29 of 365 dollars by using the tool\n\nThis can also be provided as discount application for calculating purchase discounts, coupon off, body fat, gross profit, weight loss, love, tax, populace increase & decrease, sales profit, credit cards cash earlier bonus.\n\nSee more: How Big Is A Human Head Weigh? What Is The Average Size Of The Human Head\n\nOnce you understand the values, to identify the % is simple .\n\nIf friend spot an error on this site, we would certainly be thankful if you might report the to united state by making use of the call email provided. Send email to call on our site.\n\n29 is what percent the 366 29 is what percent the 364\n\n30/366 as a percent 31 32 33 34 35 36 37 38 39 0.29/366 as a percent 1.29/366 together a percentSample Percent Calculations\n\n17 is what percent of 7115 what percent the 420370 is 78 10 is what percent of 356\n\n62/335066 as a percent 0.039 of what number is 118663 what percent that 5 is 469216\n\n0.004 that what number is 251937 how much is 20 is the end of 138729 created as a percent worth 37/138729 in percentage\n\n49 is 0.004% of what number =4237 exactly how much is 53 the end of 6316 47 is 0.004% that what number = 444" ]

[ null ]

[ "", null, "# Bibliography: Authorship index: sorted by surname (A)\n\n## Cross-index page: under construction!\n\nKeywords: (no keywords) |\nLinks: FOTW homepage | search | disclaimer and copyright | write us | mirrors\n\nContents:\n\n## Latin script\n\n### A\n\n• [ism] Aʔsmaʕil ‭(A.)‬\n• [aab] Aaby ‭(G.)‬\n• [agd] Aagedal ‭(O.)‬\n• [jaa] Aall ‭(L.)‬\n• [aar] Aarnes ‭(S.)‬\n• [aiv] Aars ‭(I.)‬\n• [aas] Aas\n• [brz] AB\n• [abz] Abaza ‭(V.)‬\n• [abb] Abbe ‭(C.)‬\n• [whb] Abdel-Wahab ‭(S)‬\n• [abl] Abeles ‭(M.)‬\n• [abs] Abelson ‭(N.)‬\n• [abj] Abér ‭(J.)‬\n• [abe] Åberg ‭(A.)‬\n• [abi] Abia ‭(J.)‬\n• [brz] abr\n• [abu] Abukhanfusa ‭(K.)‬\n• [aco] Achen ‭(C.)‬\n• [ach] Achen ‭(S.)‬\n• [hja] Achermann ‭(H.)‬\n• [aoy] Ackroyd ‭(P.)‬\n• [ugg] af Ugglas ‭(C.)‬\n• [jkl] Agnar Kl. J.\n• [agw] Agnew ‭(C.)‬\n• [yax] Âgnịxak ‭(V.)‬\n• [ape] Aguiar ‭(P.)‬\n• [agr] Aguirre ‭(M.)‬\n• [agu] Agulhon ‭(M.)‬\n• [ahr] Ahrenberg ‭(J.)‬\n• [ahn] Ahrens ‭(H.)‬\n• [aik] Aikman ‭(L.)‬\n• [akj] Aikojen ‭(K.)‬\n• [ail] Ailes ‭(A.)‬\n• [ais] Aisantiea ‭(G.)‬\n• [avz] Aivazyan ‭(S.)‬\n• [ajz] Ajnenkiel ‭(A.)‬\n• [yak] Âkimoviĉ ‭(B.)‬\n• [aks] Akselson ‭(E.)‬\n• [ala] Alardo ‭(C.)‬\n• [alw] Alban ‭(L.)‬\n• [abt] Alberti ‭(F.)‬\n• [abk] Albinsky ‭(H.)‬\n• [eff] Albrecht\n• [aji] Albrechtová ‭(J.)‬\n• [ato] Alden ‭(T.)‬\n• [roo] Alderwerelt ‭(J.)‬\n• [agt] Aldrighetti ‭(G.)‬\n• [alf] Alef ‭(G.)‬\n• [ald] Alegría ‭(J.)‬\n• [als] Ales ‭(S.)‬\n• [ale] Alexander ‭(K.)‬\n• [axa] Alexandri ‭(A.)‬\n• [zax] Alexy ‭(Z.)‬\n• [afl] Alföldi ‭(A.)‬\n• [ala] Allard ‭(C.)‬\n• [aln] Allen ‭(M.)‬\n• [aro] Allen ‭(R.)‬\n• [dle] Allessandro ‭(R.)‬\n• [alb] Allmayer-Beck ‭(J.)‬\n• [all] Allport ‭(R.)‬\n• [alm] Almgren ‭(C.)‬\n• [ags] Alonso ‭(J.)‬\n• [alg] Alt ‭(G.)‬\n• [alt] Alter ‭(P.)‬\n• [avv] Álvarez ‭(J.)‬\n• [faz] Álvarez ‭(M.el)‬\n• [azr] Álvarez ‭(M.ª)‬\n• [alv] Álvarez ‭(Ra.)‬\n• [azm] Álvarez ‭(Ru.)‬\n• [amn] Amann ‭(T.)‬\n• [aml] Amaral ‭(M.)‬\n• [azi] Amerlinck ‭(T.)‬\n• [ame] Ames\n• [amz] Amézcua ‭(M.)‬\n• [amo] Amón ‭(S.)‬\n• [atl] Amstler ‭(J.)‬\n• [atz] Amstutz ‭(W.)‬\n• [amu] Amundsen ‭(B.)‬\n• [asr] Amundsen ‭(S.)‬\n• [amy] Amy ‭(R.)‬\n• [aaw] Andersen ‭(A.)‬\n• [ajw] Anderson ‭(J.)‬\n• [ans] Anderson ‭(S.)‬\n• [ank] Andolenko ‭(S.)‬\n• [ane] Andreae ‭(B.)‬\n• [asj] Andreassen ‭(J.)‬\n• [oaw] Andrew ‭(O.)‬\n• [arj] Andrić ‭(Đ.)‬\n• [arj] Andrịĉ ‭(Dẑ.)‬\n• [anm] Andrić ‭(M.)‬\n• [ata] Andrieş-Tabac ‭(S.)‬\n• [arj] Andrit̂ ‭(D̂.)‬\n• [agl] Angell ‭(S.)‬\n• [ang] Angst ‭(W.)‬\n• [acj] Anker ‭(C.)‬\n• [akh] Ankershofen ‭(G.)‬\n• [aof] Ansoff ‭(P.)‬\n• [ant] Antonetti ‭(P.)‬\n• [ynu] Ânuŝkeviĉ ‭(I.)‬\n• [apa] Aparicio ‭(J.)‬\n• [app] Appelt ‭(H.)‬\n• [apl] Appleton ‭(D.)‬\n• [apu] Appuhn ‭(H.)‬\n• [abr] Arbel ‭(R.)‬\n• [acz] Arcarazo ‭(L.)‬\n• [arc] Arce ‭(L.)‬\n• [acx] Arceneaux ‭(T.)‬\n• [ajq] Archambault ‭(J.)‬\n• [abd] Archbold ‭(R.)‬\n• [aga] Arco ‭(F.)‬\n• [pda] Arcos ‭(I.)‬\n• [agn] Arendar ‭(G.)‬\n• [arg] Arge ‭(N.)‬\n• [ahm] Arheim ‭(T.)‬\n• [arp] Arias ‭(L.)‬\n• [ark] Arkell ‭(A.)‬\n• [amg] Armengol ‭(L.)‬\n• [ams] Armstrong ‭(E.)‬\n• [arm] Armstrong ‭(R.)‬\n• [aru] Arnau ‭(R.)‬\n• [arn] Arndt ‭(J.)‬\n• [abv] Arnold ‭(B.)‬\n• [yao] Ârova ‭(E.)‬\n• [yao] Ârova ‭(O.)‬\n• [azq] Arredondo ‭(E.)‬\n• [arr] Arrigoni ‭(M.)‬\n• [aak] Arstal ‭(A.)‬\n• [art] Artamonov ‭(V.)‬\n• [anj] Artelina\n• [arv] Artimovich ‭(N.)‬\n• [atu] Artusi ‭(L.)‬\n• [avc] Arvidsson ‭(C.)‬\n• [ase] Asensi ‭(F.)‬\n• [asp] Ashley ‭(H.)‬\n• [ash] Ashley ‭(L.)‬\n• [apt] Asperts ‭(R.)‬\n• [asn] Aspinall ‭(R.)‬\n• [atg] Atlagić ‭(M.)‬\n• [atg] Atlagid̂ ‭(М.)‬\n• [aub] Aubert ‭(L.)‬\n• [aud] Audin ‭(A.)‬\n• [auf] Aufrère ‭(G.)‬\n• [aue] Augé ‭(P.)‬\n• [aug] Augustin ‭(J.)‬\n• [avd] Avdẹẹv ‭(A.)‬\n• [avl] Avellino ‭(L.)‬\n• [avi] Avignone ‭(A.)‬\n• [vaw] Awouters ‭(L.)‬\n• [aya] Ayala ‭(L.)‬\n• [avz] Ayvazyan ‭(S.)‬\n• [azv] Azevedo ‭(F.)‬\n• [azv] Azevedo ‭(S.)‬" ]

[ null, "https://fotw.info/images/linea2.gif", null ]

[ "Solutions by everydaycalculation.com\n\n30/70 + 20/21 is 29/21.\n\n1. Find the least common denominator or LCM of the two denominators:\nLCM of 70 and 21 is 210\n2. For the 1st fraction, since 70 × 3 = 210,\n30/70 = 30 × 3/70 × 3 = 90/210\n3. Likewise, for the 2nd fraction, since 21 × 10 = 210,\n20/21 = 20 × 10/21 × 10 = 200/210\n90/210 + 200/210 = 90 + 200/210 = 290/210\n5. 290/210 simplified gives 29/21\n6. So, 30/70 + 20/21 = 29/21\nIn mixed form: 18/21\n\nMathStep (Works offline)", null, "Download our mobile app and learn to work with fractions in your own time:" ]

[ null, "https://answers.everydaycalculation.com/mathstep-app-icon.png", null ]

[ "# ECE 307\n\n## ECE 307 - Techniques for Engineering Decisions\n\n### Spring 2021\n\nTitleRubricSectionCRNTypeHoursTimesDaysLocationInstructor\nTechniques for Engrg DecisionsECE307G39322OLC30930 - 1050 T R    George Gross\n\n### Official Description\n\nModeling of decisions in engineering work and the analysis of models to develop a systematic approach to making decisions. Fundamental concepts in linear and dynamic programming; probability theory; and statistics. Resource allocation; logistics; scheduling; sequential decision making; siting of facilities; investment decisions; application of financial derivatives; other problems for decision making under uncertainty. Case studies from actual industrial applications illustrate real-world decisions. Course Information: Prerequisite: ECE 210; credit or concurrent registration in ECE 313.\n\n### Subject Area\n\nPower and Energy Systems\n\n### Description\n\nThis course is concerned with modeling of decisions and analysis of models to develop a systematic approach to making decisions. This course introduces probability theory as the fundamental mathematical basis for the development of techniques for solving typical problems faced in making engineering decisions in industry and government. The aim of this course is to teach students to think structurally about decision-making problems. Extensive use of case studies gets students involved in real world situations.\n\n### Goals\n\n1. Nature of engineering decisions; structuring of decisions; role of models; interplay of economics and technical/engineering considerations; decision making under certainty and uncertainty; good decisions vs. good outcomes; tools\n2. Resource allocation decision making using the linear programming framework; problem formulation; duality; economic interpretation; sensitivity analysis; interpretation of results\n3. Scheduling and assignment decisions using network flow concepts; transshipment problem formulation and solution; application to matching decisions; network optimization; scheduling application\n4. Sequential decision making in a dynamic programming framework; nature of dynamic programming approach; problem formulation; solution procedures\n5. Probability theory; random variables; probability distributions; expectation; conditional probability; moments; convolution\n6. Statistical concepts; data analysis; statistical measures; estimation\n7. Application of probabilistic concepts to the modeling of uncertainty in decision amking; modeling of the impacts of uncertainty; application to siting, investment and price volatility problems\n8. Decision making under uncertainty; decision trees; value of information; uses of data; sensitivity analysis and statistics\n\n### Topics\n\nDecision topics include research allocation, logistics, scheduling, sequential decision making, siting of facilities, investment decisions and other problems for decision making under uncertainty.\n\n• Resource allocation decision making using the linear programming framework: problem formulation; basic approach; duality; economic interpretation; sensitivity analysis; interpretation of results\n• Scheduling and assignment decisions using network flow concepts: trans-shipment problem formulation and solution; application to matching decisions; network optimization; scheduling applications\n• Sequential decision making in a dynamic programming framework: nature of dynamic programming approach; problem formulation; solution procedures; key limitations\n• Probability theory: random variables; probability distribution; expectation; conditional probability; moments; convolution\n• Statistical concepts: data analysis; statistical measures; estimation\n• Application of probabilistic concepts to the modeling of uncertainty in decision making: modeling of the impacts of uncertainty; applications to siting, investment and price volatility problems\n• Decision making under uncertainty: decision trees; value of information; uses of data; sensitivity analysis and statistics\n• Case Studies\n\n### Detailed Description and Outline\n\n1. Nature of engineering decisions; structuring of decisions; role of models; interplay of economics and technical/engineering considerations; decision making under certainty and uncertainty; good decisions vs. good outcomes; tools\n2. Resource allocation decision making using the linear programming framework; problem formulation; duality; economic interpretation; sensitivity analysis; interpretation of results\n3. Scheduling and assignment decisions using network flow concepts; transshipment problem formulation and solution; application to matching decisions; network optimization; scheduling application\n4. Sequential decision making in a dynamic programming framework; nature of dynamic programming approach; problem formulation; solution procedures\n5. Probability theory; random variables; probability distributions; expectation; conditional probability; moments; convolution\n6. Statistical concepts; data analysis; statistical measures; estimation\n7. Application of probabilistic concepts to the modeling of uncertainty in decision amking; modeling of the impacts of uncertainty; application to siting, investment and price volatility problems\n8. Decision making under uncertainty; decision trees; value of information; uses of data; sensitivity analysis and statistics\n\nTopics:\n\nDecision topics include research allocation, logistics, scheduling, sequential decision making, siting of facilities, investment decisions and other problems for decision making under uncertainty.\n• Resource allocation decision making using the linear programming framework: problem formulation; basic approach; duality; economic interpretation; sensitivity analysis; interpretation of results\n• Scheduling and assignment decisions using network flow concepts: trans-shipment problem formulation and solution; application to matching decisions; network optimization; scheduling applications\n• Sequential decision making in a dynamic programming framework: nature of dynamic programming approach; problem formulation; solution procedures; key limitations\n• Probability theory: random variables; probability distribution; expectation; conditional probability; moments; convolution\n• Statistical concepts: data analysis; statistical measures; estimation\n• Application of probabilistic concepts to the modeling of uncertainty in decision making: modeling of the impacts of uncertainty; applications to siting, investment and price volatility problems\n• Decision making under uncertainty: decision trees; value of information; uses of data; sensitivity analysis and statistics\n• Case Studies and Presentations\n\n### Course Goals\n\nThis course is an elective for both electrical and computer engineering majors. The goals are to provide the students with systematic approaches to making decisions, exposes students to the requisite analytical tools and approaches and provides illustrative examples and team projects of case studies for application of these tools and methodologies.\n\n### Instructional Objectives\n\n1. After the first six weeks of class, the students will be able to do the following:\n\n1. Perform fundamental resource allocation analysis using linear programming (1, 2, 6)\n\n2. Make scheduling and assignment decisions using network flow concepts (1, 2, 6)\n\n3. Model the decision process in a mathematical programming framework (1, 4, 6)\n\n4. Understand the insights that the duality framework provides and deploy its application to help solve the primal problems making use of duality information (1, 2, 4, 6)\n\nB. After the first nine weeks of class, the students will be able to to do all of the items listed under A above, plus the following:\n\n5. Model problems in matching jobs and people, scheduling and project management as network flow problems and apply the shortest path algorithm to solve resource allocation problems (1, 2, 4, 6)\n\n6. Perform sequential decision making in a dynamic programming environment (1, 2, 4, 6)\n\n7. Use deterministic programming techniques to solve a broad range of deterministic decision making problems (1, 2, 4, 6)\n\n8. Participate in Team Project 1 to showcase the solution of a deterministic decision making problem, preparation of a written report and the presentation of the results to the class (1, 2, 3, 4, 5, 6)\n\nC. After the first 12 weeks of class, the students should be able to do all of the items listed under A and B above, plus the following:\n\n9. Review the concepts of combinations and permutations and the basic axioms and theoems of probability and solve Bayesian analysis problems for relatively complex problems (1, 2, 4, 6)\n\n10. Review specific parametric discrete and continuous probability distribution functions and their application to the representation of uncertainty in realistic models for decision making under uncertainty (1, 2, 6)\n\n11. Perform basic statistical analysis including estimation (1, 2, 6)\n\n12. Apply Monte Carlo simulation to analyze uncertainty representation in situations in which the probability distributions are unknown (1, 2, 4, 6)\n\n13. Apply conditional probability to evaluate the worth of perfect and imperfect information (1, 2, 6)\n\n14. Participate in Team Project 2 to showcase the solution of a decision making problem under uncertainty, preparation of a written report and the presentation of the results to the class to convince others of the soundness of recommended actions (1, 2, 3, 4, 5, 6)\n\n15. Understand the concept of financial derivative, including forward contracts, futures and options and their application to engineering problems (1, 2, 6)\n\n16. Understand the value at risk concept and apply it to study its use for a portfolio of investments (1, 2, 4, 5, 6)\n\n### Last updated\n\n5/20/2019by George Gross" ]

[ null ]

[ "# zbMATH — the first resource for mathematics\n\nAsymptotics of $$q$$-orthogonal polynomials and a $$q$$-Airy function. (English) Zbl 1072.33014\nLet $$0<q<1$$. The polynomials $$h_{n}(x\\,| \\,q)$$ satisfy the recurrence relation $2xh_{n}(x\\,| \\,q)=h_{n+1}(x\\,| \\,q)+q^{-n}(1-q^n)h_{n-1}(x\\,| \\,q)$ with $$h_{0}(x\\,| \\,q)=1$$ and $$h_{1}(x\\,| \\,q)=2x$$. These polynomials are $$q$$-analogues of the Hermite polynomials $$H_{n}(x)$$. A $$q$$-analogue of the Laguerre polynomials $$L_{n}^{(\\alpha)}(x)$$ is the system of polynomials $$L_{n}^{(\\alpha)}(x;q)$$ generated by\n$\\begin{split} -xq^{2n+\\alpha+1}L_{n}^{(\\alpha)}(x;q)=\\\\ (1-q^{n+1})L_{n+1}^{(\\alpha)}(x;q)+ q(1-q^{n+\\alpha})L_{n-1}^{(\\alpha)}(x;q)] -[(1-q^{n+1})+ q(1-q^{n+\\alpha})]L_{n}^{(\\alpha)}(x;q) \\end{split}$ and the initial conditions\n$L_{0}^{(\\alpha)}(x;q)=1,\\quad L_{1}^{(\\alpha)}(x;q)= \\frac{1-q^{\\alpha+1}- xq^{\\alpha+1}}{1-q}.$ In this paper, the author establishes complete asymptotic expansions of $$h_{n}(x\\,| \\,q)$$ and $$L_{n}^{(\\alpha)}(x;q)$$ around their largest zero. A similar formula is also derived for the Stieltjes-Wigert polynomials $S_{n}(x;q)= \\sum_{k=0}^{n}\\frac{q^{k^2}(-x)^{k}}{(q;q)_{k}(q;q)_{n-k}}.$ In doing so, he discovers a $$q$$-analogue of the Airy function, namely $A_{q}(z)=\\sum_{k=0}^{\\infty}\\frac{q^{k^2}(-z)^{k}}{(q;q)_{k}}.$ He also derives Plancherel-Rotach-type asymptotics for the polynomials $$Q_{n}(x)$$ generated by $Q_{0}(x)=1,\\;Q_{1}(x)=2x-a-b,\\;Q_{n+1}(x)= [2x-(a+b)q^{-n}]Q_{n}(x)-(ab+q^{n-1})Q_{n-1}(x).$ The term Plancherel-Rotach asymptotics refers to asymptotics around the largest and smallest zeros. The polynomials $$Q_{n}(x)$$ are Al-Salam-Chichara polynomials with $$q \\rightarrow 1/q$$. The author also establishes asymptotic formulas of Plancherel-Rotach-type for all $$q$$-polynomials in the Askey scheme, which are orthogonal on unbounded sets.\n\n##### MSC:\n 33D45 Basic orthogonal polynomials and functions (Askey-Wilson polynomials, etc.) 33D15 Basic hypergeometric functions in one variable, $${}_r\\phi_s$$ 33C10 Bessel and Airy functions, cylinder functions, $${}_0F_1$$ 33C45 Orthogonal polynomials and functions of hypergeometric type (Jacobi, Laguerre, Hermite, Askey scheme, etc.)\nFull Text:" ]

[ null ]

[ "# Using the CMA-ES algorithm to optimize the position of wind turbines\n\nI have an implementation of an optimization algorithm called the Covariance Matrix Adaptation Evolutionary Strategy (CMA-ES). I am using this algorithm to optimize the position of wind turbines inside a wind farm, but if I place more than a certain number of turbines (equivalent to a high value of N at the beginning of the code) after around 50 iterations of the while loop, my RAM memory is filled. I have tried using deletion of certain variables after they are being used and using slots in my class declaration but to no noticeable effect.\n\nCould you take a look at the code and tell me if there is something very memory consuming that I'm not seeing?\n\nThis is a stand-alone, coupled with the Rosenbrock function to optimize.\n\ndef frosenbrock(x):\nx1=np.delete(x,len(x)-1);\nx2=np.delete(x,0);\nf = 100*sum(((x1**2) - (x2))**2) + sum((x1-1)**2);\nreturn f;\n\ndef optimise_CMA(self,initial_guess):\n#--------------INITIALIZATION----------------------\nN=20 #Number of variables, problem dimension\n#Container for coordinates called xmean\nxmean=[] #Objective variables (coordinates)initial point\nfor i in range(int(N)):\nxmean.append([random.uniform(0,1)]);\nxmean=np.asarray(xmean,dtype=np.float_)\nsigma=0.5 #Coordinate wise standard deviation\nstopfitness = 1e-10 #stop if fitness < stopfitness (minimization)\nstopeval =1e3*N**2 #stop after this number of evaluations ()\n\n#Strategy parameter setting: Selection\nlambd=int(4.0+floor(3.0*log(N))) #population size, offspring number\nmu=(lambd/2) #number of parents/points for recombination\nweights=np.array([])\nfor j in range(mu):\nweights=np.append(weights,log(mu+0.5)-log(j+1))#muXone array for weighted recombination\nmu = floor(mu)\nweights=weights/sum(weights)\nmueff=sum(weights)**2/sum(weights**2)\nweights_array=weights.reshape([mu,1])\n\ncc=(4+mueff/N)/(N+4 + 2*mueff/N) #time constant for cumulation for C\ncs=(mueff+2)/(N+mueff+5) #t-const for cumulation for sigma control\nc1=2/((N+1.3)**2+mueff) #learning rate for rank-one update of C\ncmu=min(1-c1,2*(mueff-2+1/mueff)/((N+2)**2+mueff)) #and for rank-mu update\ndamps =1 +2*max(0,sqrt((mueff-1)/(N+1))-1)+cs #damping for sigma, usually close to 1\n\n#Initialize dynamic (internal) strategy parameters and constants\npc=np.zeros((N,1),dtype=np.float_) #evolution path for C\nps=np.zeros((N,1),dtype=np.float_) #evolution path for sigma\nD=np.ones((N,1),dtype=np.float_) #diagonal D defines the scaling\nB =np.eye(N,dtype=np.float_) #B defines the coordinate system\nD_sqd=D**2\ndiag_D_sqd=(np.diag(D_sqd[:,0])) #Generate diagonal matrix with D_sqd in the diagonal, the rest are zeros\ntrans_B=B.transpose() #Tranpose matrix of B\nC=np.dot(np.dot(B,diag_D_sqd),trans_B)#Covariance matrix C\nnega_D=D**(-1) #Elementwise to power -1\ndiag_D_neg=(np.diag(nega_D[:,0])) #Generate diagonal matrix with nega_D in diagonal, rest zeros\ninvsqrtC =np.dot(np.dot(B,diag_D_neg),trans_B)#C^-1/2\neigeneval = 0 #track update of B and D\nchiN=N**0.5*(1-1/(4*N)+1/(21*N**2)) #expectation of ||N(0,I)|| == norm(randn(N,1))\n\n#---------GENERATION LOOP---------------\ncounteval=0\narx=[]\nwhile counteval<stopeval:\n#Generate and evaluate lamba offspring\nitera=1\narfitness=[]\nfor l in range(lambd):\noffspring=[] #Create a container for the offspring\noffspring=xmean+np.dot(sigma*B,(D*np.random.standard_normal((N,1)))) #m + sig * Normal(0,C)\nif itera==1:\narx=offspring\nelse:\narx=np.hstack((arx,offspring))\narfitness.append(frosenbrock(offspring)) #EVALUATE OBJ FUNCTION\ncounteval=counteval+1\nitera=itera+1\n#Sort by fitness and compute weighted mean into xmean\nordered=[]\nordered=sorted(enumerate(arfitness), key=lambda x: x) #minimization, list with (Index,Fitness) elements\nxold=xmean\nbest_off_indexes=[]\nfor i in range(int(mu)):\nbest_off_indexes.append(ordered[i]) #List of best indexes of mu offspring\nrecomb=np.zeros([N,mu])\ncont=0\nfor index in best_off_indexes:\nrecomb[:,cont]=arx[:,index]\ncont=cont+1\nxmean=np.dot(recomb,weights_array)\n\n#Cumulation: update evolution paths\nps=(1-cs)*ps+sqrt(cs*(2-cs)*mueff)*np.dot(invsqrtC,(xmean-xold))*(1/sigma)\nhsig=np.linalg.norm(ps)/sqrt(1-(1-cs)**(2*counteval/lambd))/chiN < 1.4 + 2/(N+1)\nif hsig==True:\nhsig=1\nelse:\nhsig=0\npc=(1-cc)*pc+hsig*sqrt(cc*(2-cc)*mueff)*(xmean-xold)/sigma\n\nartmp=(1/sigma)*(recomb-np.tile(xold,(1,mu)))\nweights_diag=np.diag(weights_array[:,0])\nC=(1-c1-cmu)*C+c1*(np.dot(pc,pc.transpose())+((1-hsig)*cc*(2-cc)*C))+cmu*np.dot(artmp,np.dot(weights_diag,artmp.transpose()))\n\nsigma=sigma*exp((cs/damps)*(np.linalg.norm(ps)/chiN - 1))\n\n#Decomposition of C into B*diag(D.^2)*B' (diagonalization)\nif counteval-eigeneval > lambd/(c1+cmu)/N/10:\neigeneval=counteval #to achieve O(N^2)\nC=np.triu(C)+np.triu(C,1).transpose() #enforce symmetry\nB=np.linalg.eig(C) #eigen decomposition, B==normalized eigenvectors\ndiag_D=np.linalg.eig(C)\ndiag_D=diag_D.reshape([N,1])\nD=diag_D**0.5 #D is a vector of standard deviations now\nD_inv=D**(-1)\nD_inv=np.diag(D_inv[:,0])\ninvsqrtC=np.dot(B,np.dot(D_inv,B.transpose()))\nprint ordered; # Uncomment to see convergence in the console\n#Break, if fitness is good enough or condition exceeds 1e14, better termination methods are advisable\ndel arfitness\nif ordered<=stopfitness or max(D)>1e7*min(D):\nbreak\nelse:\ndel arx\ndel ordered\n#Return best point at last iteration\nxmin=arx[:,best_off_indexes]\nreturn xmin\n\n• Could you provide test code that invokes the above in a way that you expect reproduces the memory issue? – Reinderien Dec 20 '14 at 4:32\n\n1. First off, style. Your code is... not very well styled. You have many PEP8 violations. Here's a list of those violations.\n\n1. You have no space between operators/variable declarations. You should have one space between operators, like this: a + b, a == b, or var = 10.\n2. Secondly, your variable names need to be more descriptive. Names like cont, arx, or l are not good. Names should be not too short, not too long, and as descriptive as possible.\n3. You need two blank lines between functions.\n2. I'm not quite sure on this, but I think you issue with memory stems from the fact that you're doing many intensive calculations. Python is not Mathematica or R, which means that it isn't built specifically to do calculations like this. You could use a mathematical library, like numpy, as well. See if you can shorten or simplify some of your expressions.\n\n3. You're also doing a ton of looping, which can hang the program, especially with all those calculations. See where loops can be shortened.\n4. Finally, it seems like you're allocating quite a bit of items to lists. If you can remove lists after they're needed, this may speed up your execution time.\nimport numpy as np\nimport math\ndef frosenbrock(x):\n\nx1 = x\nx2 = x\nval = 100. * (x2 - x1 ** 2.) ** 2. + (1 - x1) ** 2.\nreturn val;\n\ndef optimise_CMA(initial_guess):\n#--------------INITIALIZATION----------------------\nN=2 #Number of variables, problem dimension\n#Container for coordinates called xmean\nxmean=initial_guess #Objective variables (coordinates)initial point\nif len(xmean) == 0:\nfor i in range(int(N)):\nxmean.append([random.uniform(0,1)]);\n\nxmean=np.array(xmean,dtype=np.float_).reshape(N,1)\nsigma=0.5 #Coordinate wise standard deviation\nstopfitness = 1e-10 #stop if fitness < stopfitness (minimization)\n# stopeval =1e3*N**2 #stop after this number of evaluations ()\nstopeval = 100 #stop after this number of evaluations ()\n\n#Strategy parameter setting: Selection\nlambd=int(4.0+math.floor(3.0*np.log(N))) #population size, offspring number\nmu=int(lambd/2) #number of parents/points for recombination\nweights=np.array([])\nfor j in range(mu):\nweights=np.append(weights,np.log(mu+0.5)-np.log(j+1))#muXone array for weighted recombination\nmu = math.floor(mu)\nweights=weights/sum(weights)\nmueff=sum(weights)**2/sum(weights**2)\nweights_array=weights.reshape([mu,1])\n\ncc=(4+mueff/N)/(N+4 + 2*mueff/N) #time constant for cumulation for C\ncs=(mueff+2)/(N+mueff+5) #t-const for cumulation for sigma control\nc1=2/((N+1.3)**2+mueff) #learning rate for rank-one update of C\ncmu=min(1-c1,2*(mueff-2+1/mueff)/((N+2)**2+mueff)) #and for rank-mu update\ndamps =1 +2*max(0,np.sqrt((mueff-1)/(N+1))-1)+cs #damping for sigma, usually close to 1\n\n#Initialize dynamic (internal) strategy parameters and constants\npc=np.zeros((N,1),dtype=np.float_) #evolution path for C\nps=np.zeros((N,1),dtype=np.float_) #evolution path for sigma\nD=np.ones((N,1),dtype=np.float_) #diagonal D defines the scaling\nB =np.eye(N,dtype=np.float_) #B defines the coordinate system\nD_sqd=D**2\ndiag_D_sqd=(np.diag(D_sqd[:,0])) #Generate diagonal matrix with D_sqd in the diagonal, the rest are zeros\ntrans_B=B.transpose() #Tranpose matrix of B\nC=np.dot(np.dot(B,diag_D_sqd),trans_B)#Covariance matrix C\nnega_D=D**(-1) #Elementwise to power -1\ndiag_D_neg=(np.diag(nega_D[:,0])) #Generate diagonal matrix with nega_D in diagonal, rest zeros\ninvsqrtC =np.dot(np.dot(B,diag_D_neg),trans_B)#C^-1/2\neigeneval = 0 #track update of B and D\nchiN=N**0.5*(1-1/(4*N)+1/(21*N**2)) #expectation of ||N(0,I)|| == norm(randn(N,1))\n\n#---------GENERATION LOOP---------------\ncounteval=0\narx=[]\nbest_fitness = 100000000\nwhile counteval<stopeval:\n#Generate and evaluate lamba offspring\nitera=1\narfitness=[]\nfor l in range(lambd):\noffspring=[] #Create a container for the offspring\noffspring = xmean + sigma * np.dot(B,(np.multiply(D,np.random.standard_normal((N,1))))) #m + sig * Normal(0,C)\nif itera==1:\narx=offspring\nelse:\narx=np.hstack((arx,offspring))\narfitness.append(frosenbrock(offspring)) #EVALUATE OBJ FUNCTION\ncounteval=counteval+1\nitera=itera+1\n#Sort by fitness and compute weighted mean into xmean\nordered=[]\nordered=sorted(enumerate(arfitness), key=lambda x: x) #minimization, list with (Index,Fitness) elements\nxold=xmean\nbest_off_indexes=[]\nfor i in range(int(mu)):\nbest_off_indexes.append(ordered[i]) #List of best indexes of mu offspring\nrecomb=np.zeros([N,mu])\ncont=0\nfor index in best_off_indexes:\nrecomb[:,cont]=arx[:,index]\ncont=cont+1\nxmean=np.dot(recomb,weights_array)\n\n#Cumulation: update evolution paths\nps=(1-cs)*ps+np.sqrt(cs*(2-cs)*mueff)*np.dot(invsqrtC,(xmean-xold))*(1/sigma)\nhsig=np.linalg.norm(ps)/np.sqrt(1-(1-cs)**(2*counteval/lambd))/chiN < 1.4 + 2/(N+1)\nif hsig==True:\nhsig=1\nelse:\nhsig=0\npc=(1-cc)*pc+hsig*np.sqrt(cc*(2-cc)*mueff)*(xmean-xold)/sigma\n\nartmp=(1/sigma)*(recomb-np.tile(xold,(1,mu)))\nweights_diag=np.diag(weights_array[:,0])\nC=(1-c1-cmu)*C+c1*(np.dot(pc,pc.transpose())+((1-hsig)*cc*(2-cc)*C))+cmu*np.dot(artmp,np.dot(weights_diag,artmp.transpose()))\n\nsigma=sigma*np.exp((cs/damps)*(np.linalg.norm(ps)/chiN - 1))\n\n#Decomposition of C into B*diag(D.^2)*B' (diagonalization)\nif counteval-eigeneval > lambd/(c1+cmu)/N/10:\neigeneval=counteval #to achieve O(N^2)\nC=np.triu(C)+np.triu(C,1).transpose() #enforce symmetry\nB=np.linalg.eig(C) #eigen decomposition, B==normalized eigenvectors\ndiag_D=np.linalg.eig(C)\ndiag_D=diag_D.reshape([N,1])\nD=diag_D**0.5 #D is a vector of standard deviations now\nD_inv=D**(-1)\nD_inv=np.diag(D_inv[:,0])\ninvsqrtC=np.dot(B,np.dot(D_inv,B.transpose()))\n# print (ordered); # Uncomment to see convergence in the console\n#Break, if fitness is good enough or condition exceeds 1e14, better termination methods are advisable\n# del arfitness\n# if ordered<=stopfitness or max(D)>1e7*min(D):\n# break\n# else:\n# del arx\n# del ordered\n#Return best point at last iteration\n\nif min(arfitness) < best_fitness:\nbest_fitness = min(arfitness)\nbest_conf = arx[:,best_off_indexes]\nxmin=arx[:,best_off_indexes]\nprint(best_fitness,best_conf)\nreturn xmin\n\n\nxmean must be a 2d array and offspring formulation was wrong. D .* randn(nGenes,1) involves Element wise multiplication.\n\noffspring = xmean + sigma * np.dot(B,(np.multiply(D,np.random.standard_normal((N,1))))) #m + sig * Normal(0,C)" ]

[ null ]

[ "GMAT Question of the Day - Daily to your Mailbox; hard ones only\n\n It is currently 17 Jun 2019, 08:24", null, "GMAT Club Daily Prep\n\nThank you for using the timer - this advanced tool can estimate your performance and suggest more practice questions. We have subscribed you to Daily Prep Questions via email.\n\nCustomized\nfor You\n\nwe will pick new questions that match your level based on your Timer History\n\nTrack\n\nevery week, we’ll send you an estimated GMAT score based on your performance\n\nPractice\nPays\n\nwe will pick new questions that match your level based on your Timer History\n\nNot interested in getting valuable practice questions and articles delivered to your email? No problem, unsubscribe here.", null, "", null, "A natural number p, when divided by a certain divisor q, gives\n\nAuthor Message\nTAGS:\n\nHide Tags\n\nManager", null, "", null, "G\nJoined: 15 Dec 2015\nPosts: 115\nGMAT 1: 660 Q46 V35", null, "GPA: 4\nWE: Information Technology (Computer Software)\nA natural number p, when divided by a certain divisor q, gives  [#permalink]\n\nShow Tags\n\n1\n11", null, "00:00\n\nDifficulty:", null, "", null, "", null, "95% (hard)\n\nQuestion Stats:", null, "24% (03:11) correct", null, "76% (02:17) wrong", null, "based on 181 sessions\n\nHideShow timer Statistics\n\nA natural number p, when divided by a certain divisor q, gives remainder 12, what is the value of q?\n\n(1) When 2p is divided by q, the remainder is 2.\n(2) When 3p is is divided by q, the remainder is 6.\n\nOriginally posted by DHAR on 30 Jul 2017, 08:28.\nLast edited by DHAR on 30 Jul 2017, 20:18, edited 2 times in total.\nMath Expert", null, "V\nJoined: 02 Aug 2009\nPosts: 7749\nRe: A natural number p, when divided by a certain divisor q, gives  [#permalink]\n\nShow Tags\n\n3\n3\nDH99 wrote:\nA natural number p, when divided by a certain divisor q, gives remainder 12, what is the value of q?\n\nStatement 1: When 2p is divided by q, the remainder is 2.\nStatement 2: When 3p is is divided by q, the remainder is 6.\n\nHi..\nwhen p is div by q , remainder is 12..\n\nlets see the statements..\n\nStatement 1: When 2p is divided by q, the remainder is 2.\nIf p divided by q , 12 is the remainder.\nso 2p divided by q should gives us remainder 2*12=24..\n\nbut the remainder is 2 so 24-2=22 should be div by q..\nq can be 2,11,22 but q>12 as the remainder in initial case was 12\nans q is 22\nsufficient\n\nStatement 2: When 3p is is divided by q, the remainder is 6.\nso remainder should have been 3*12=36..\nso 30 is div by q..\nso q could be 10,15,30..\nbut q>12, so possible values 15 or 30...\nso two values possible\nInsuff..\n\nA..\n\nthe problem with the Q is that it does not give the value 22 in statement II, which is not possible in actual gmat. each statement has to point towards the actual value..\n_________________\nGeneral Discussion\nSVP", null, "", null, "V\nJoined: 26 Mar 2013\nPosts: 2231\nRe: A natural number p, when divided by a certain divisor q, gives  [#permalink]\n\nShow Tags\n\nchetan2u wrote:\nDH99 wrote:\nA natural number p, when divided by a certain divisor q, gives remainder 12, what is the value of q?\n\nStatement 1: When 2p is divided by q, the remainder is 2.\nStatement 2: When 3p is is divided by q, the remainder is 6.\n\nHi..\nwhen p is div by q , remainder is 12..\n\nlets see the statements..\n\nStatement 1: When 2p is divided by q, the remainder is 2.\nIf p divided by q , 12 is the remainder.\nso 2p divided by q should gives us remainder 2*12=24..\nbut the remainder is 2 so 24-2=22 should be div by q..\n\nq can be 2,11,22 but q>12 as the remainder in initial case was 12\nans q is 22\nsufficient\n\nDear chetan2u,\n\nCan you please elaborate the above highlighted? Why should it divided by 'q' after subtracting 2 from 24?\n\nThanks\nMath Expert", null, "V\nJoined: 02 Sep 2009\nPosts: 55631\nRe: A natural number p, when divided by a certain divisor q, gives  [#permalink]\n\nShow Tags\n\nDH99 wrote:\nA natural number p, when divided by a certain divisor q, gives remainder 12, what is the value of q?\n\n(1) When 2p is divided by q, the remainder is 2.\n(2) When 3p is is divided by q, the remainder is 6.\n\nPlease name topics properly. Read rule 3 in our RULES OF POSTING. Thank you.\n_________________\nMath Expert", null, "V\nJoined: 02 Aug 2009\nPosts: 7749\nA natural number p, when divided by a certain divisor q, gives  [#permalink]\n\nShow Tags\n\nMo2men wrote:\nchetan2u wrote:\nDH99 wrote:\nA natural number p, when divided by a certain divisor q, gives remainder 12, what is the value of q?\n\nStatement 1: When 2p is divided by q, the remainder is 2.\nStatement 2: When 3p is is divided by q, the remainder is 6.\n\nHi..\nwhen p is div by q , remainder is 12..\n\nlets see the statements..\n\nStatement 1: When 2p is divided by q, the remainder is 2.\nIf p divided by q , 12 is the remainder.\nso 2p divided by q should gives us remainder 2*12=24..\nbut the remainder is 2 so 24-2=22 should be div by q..\n\nq can be 2,11,22 but q>12 as the remainder in initial case was 12\nans q is 22\nsufficient\n\nDear chetan2u,\n\nCan you please elaborate the above highlighted? Why should it divided by 'q' after subtracting 2 from 24?\n\nThanks\n\nHi..\n\nRemember..\n1) whenever you add two numbers, the remainder they leave gets added..\n17 gives a remainder 3 when div by 7 and 22 gives remainder 1 when div by 7..\nSo 17+22 should give 3+1 when div by 7..\nLet's see 17+22=39.. remainder is 4 as 39-35\n2) next when you multiply two numbers their remainder gets multiplied..\nSay 8 gives a remainder 1 when div by 7 and 2 gives a remainder 2..\nSo 8*2 should give 1*2 or 2 when div by 7..\nLet's see 8*2=16.. leaves a remainder 2, 16-12..\n\nThe point (2) I the reason why we multiply 2*11\n\nNow 24 should have been the remainder but it is 2 so 24-2 should be div..\nYou can see that thru equation also\n\nHope it helps\n_________________\nSenior Manager", null, "", null, "G\nJoined: 02 Apr 2014\nPosts: 477\nLocation: India\nSchools: XLRI\"20\nGMAT 1: 700 Q50 V34", null, "GPA: 3.5\nA natural number p, when divided by a certain divisor q, gives  [#permalink]\n\nShow Tags\n\n2\n\nLet $$p = aq + 12$$, where a is any integer\n=> $$2p = 2aq + 24$$\n=> $$3p = 3aq + 36$$\n\nStatement 1:\n2p divided by q leaves 2 as remainder => $$2p = bq + 2$$\nfrom above, $$2p = 2aq + 24$$, equating both\n=> $$bq + 2 = 2aq + 24$$\n=> $$q = 22/(b - 2a)$$\n=> q has to be factor of 22, however can't be less than 12, it leaves remainder 12, so only\nfactor of 22, greater than 12 is 22 itself, so q = 22 -> Sufficient\n\nStatement 2:\n\n3p divided by q leaves 6 as remainder => $$3p = cq + 6$$\nfrom above, $$3p = 3aq + 36$$, equating both\n=> $$cq + 6 = 3aq + 36$$\n=> $$q = 30/(c - 3a)$$\n=> q has to be factor of 30, possible values are 15, 30 (which are greater than 12)\n=> Not Sufficient.\n\nchetan2u Bunuel But Statement 1 and 2 contradicting each other, statement 1: q -> 12 and statement 2: q -> {15,30}\nRetired Moderator", null, "P\nJoined: 22 Aug 2013\nPosts: 1438\nLocation: India\nRe: A natural number p, when divided by a certain divisor q, gives  [#permalink]\n\nShow Tags\n\nhellosanthosh2k2 wrote:\n\nLet $$p = aq + 12$$, where a is any integer\n=> $$2p = 2aq + 24$$\n=> $$3p = 3aq + 36$$\n\nStatement 1:\n2p divided by q leaves 2 as remainder => $$2p = bq + 2$$\nfrom above, $$2p = 2aq + 24$$, equating both\n=> $$bq + 2 = 2aq + 24$$\n=> $$q = 22/(b - 2a)$$\n=> q has to be factor of 22, however can't be less than 12, it leaves remainder 12, so only\nfactor of 22, greater than 12 is 22 itself, so q = 22 -> Sufficient\n\nStatement 2:\n\n3p divided by q leaves 6 as remainder => $$3p = cq + 6$$\nfrom above, $$3p = 3aq + 36$$, equating both\n=> $$cq + 6 = 3aq + 36$$\n=> $$q = 30/(c - 3a)$$\n=> q has to be factor of 30, possible values are 15, 30 (which are greater than 12)\n=> Not Sufficient.\n\nchetan2u Bunuel But Statement 1 and 2 contradicting each other, statement 1: q -> 12 and statement 2: q -> {15,30}\n\nHi\n\nIts okay the statements are contradicting each other here, since ONLY one statement is giving us the answer. (statement 1)\n\nWe should not have a scenario where the answer is D (from each statement alone) and we get different/contradicting answers from the two statements. Then thats an issue and we need to check whether we have done everything correct or not.\n\nEg; if our answer is D, and we are getting q=22 from first statement and q=15 from second statement THEN thats a problem.\nNon-Human User", null, "Joined: 09 Sep 2013\nPosts: 11376\nRe: A natural number p, when divided by a certain divisor q, gives  [#permalink]\n\nShow Tags\n\nHello from the GMAT Club BumpBot!\n\nThanks to another GMAT Club member, I have just discovered this valuable topic, yet it had no discussion for over a year. I am now bumping it up - doing my job. I think you may find it valuable (esp those replies with Kudos).\n\nWant to see all other topics I dig out? Follow me (click follow button on profile). You will receive a summary of all topics I bump in your profile area as well as via email.\n_________________", null, "Re: A natural number p, when divided by a certain divisor q, gives   [#permalink] 02 Dec 2018, 04:08\nDisplay posts from previous: Sort by\n\nA natural number p, when divided by a certain divisor q, gives", null, "", null, "" ]

[ null, "https://cdn.gmatclub.com/cdn/files/forum/styles/gmatclub_light/theme/images/profile/close.png", null, "https://cdn.gmatclub.com/cdn/files/forum/styles/gmatclub_light/theme/images/profile/close.png", null, "https://gmatclub.com/forum/styles/gmatclub_light/theme/images/search/close.png", null, "https://cdn.gmatclub.com/cdn/files/forum/images/ranks/rank_phpbb_3.svg", null, "https://cdn.gmatclub.com/cdn/files/forum/images/avatars/upload/avatar_554836.jpg", null, "https://gmatclub.com/forum/images/verified_score.svg", null, "https://cdn.gmatclub.com/cdn/files/forum/styles/gmatclub_light/theme/images/viewtopic/timer_play.png", null, "https://cdn.gmatclub.com/cdn/files/forum/styles/gmatclub_light/theme/images/viewtopic/timer_difficult_blue.png", null, "https://cdn.gmatclub.com/cdn/files/forum/styles/gmatclub_light/theme/images/viewtopic/timer_difficult_blue.png", null, "https://cdn.gmatclub.com/cdn/files/forum/styles/gmatclub_light/theme/images/viewtopic/timer_difficult_blue.png", null, "https://cdn.gmatclub.com/cdn/files/forum/styles/gmatclub_light/theme/images/viewtopic/timer_separator.png", null, "https://cdn.gmatclub.com/cdn/files/forum/styles/gmatclub_light/theme/images/viewtopic/timer_separator.png", null, "https://cdn.gmatclub.com/cdn/files/forum/styles/gmatclub_light/theme/images/viewtopic/timer_separator.png", null, "https://cdn.gmatclub.com/cdn/files/forum/images/avatars/upload/avatar_70884.jpg", null, "https://cdn.gmatclub.com/cdn/files/forum/images/ranks/rank_phpbb_7.svg", null, "https://cdn.gmatclub.com/cdn/files/forum/images/avatars/upload/avatar_326461.jpg", null, "https://cdn.gmatclub.com/cdn/files/forum/images/avatars/upload/avatar_73391.jpg", null, "https://cdn.gmatclub.com/cdn/files/forum/images/avatars/upload/avatar_70884.jpg", null, "https://cdn.gmatclub.com/cdn/files/forum/images/ranks/rank_phpbb_4.svg", null, "https://cdn.gmatclub.com/cdn/files/forum/images/no_avatar.svg", null, "https://gmatclub.com/forum/images/verified_score.svg", null, "https://cdn.gmatclub.com/cdn/files/forum/images/no_avatar.svg", null, "https://cdn.gmatclub.com/cdn/files/forum/images/avatars/upload/avatar_362269.gif", null, "https://cdn.gmatclub.com/cdn/files/forum/styles/gmatclub_light/theme/images/viewtopic/posts_bot.png", null, "https://www.facebook.com/tr", null, "https://www.googleadservices.com/pagead/conversion/1071875456/", null ]

[ "", null, "# EPI dynamic programming question - \"find max subarray\" has incorrect solution\n\n#1\n\nEPI dynamic programming question - “find max subarray” has incorrect solution.\n\nclass Solution:\ndef maxSubArray(self, nums: List[int]) -> int:\nminsum = maxsum = nums\nfor runningsum in itertools. accumulate (nums) :\nminsum = min(minsum, runningsum)\nmaxsum = max(maxsum, runningsum - minsum)\nreturn maxsum\n\nsolution dont work for all negative numbers.\n\ninput [-1, -2, -2] would return 0 with this solution.\n\n0 Likes" ]

[ null, "http://talk.elementsofprogramminginterviews.com/images/d-logo-sketch.png", null ]

[ "", null, "", null, "### Home > MC2 > Chapter 8 > Lesson 8.2.2 > Problem8-45\n\n8-45.\n\nThe table below shows speed limits in some foreign countries in kilometers per hour. One kilometer is equal to $0.6$ miles. What are these speed limits in miles per hour?\n\nCountry Country Roads Motorways Speed Limits in km per hour Australia $100$ $110$ South Africa $100$ $120$ Great Britain $96$ $112$ Turkey $90$ $90$\n\nConvert each speed limit value into miles per hour based on the conversion factor given.\n\nGreat Britain:\nCountry Roads: $58$ miles per hour\nMotorways: $67$ miles per hour\n\nAustralia:\nCountry Roads: $100 · 0.6 = 60$ miles per hour\nMotorways: $110 · 0.6 = 66$ miles per hour" ]

[ null, "https://homework.cpm.org/dist/7d633b3a30200de4995665c02bdda1b8.png", null, "data:image/png;base64,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", null ]

[ "Solutions by everydaycalculation.com\n\n## Compare 18/90 and 7/35\n\n18/90 is equivalent to 7/35\n\n#### Steps for comparing fractions\n\n1. Find the least common denominator or LCM of the two denominators:\nLCM of 90 and 35 is 630\n\nNext, find the equivalent fraction of both fractional numbers with denominator 630\n2. For the 1st fraction, since 90 × 7 = 630,\n18/90 = 18 × 7/90 × 7 = 126/630\n3. Likewise, for the 2nd fraction, since 35 × 18 = 630,\n7/35 = 7 × 18/35 × 18 = 126/630\n4. Since the denominators are now the same, the fraction with the bigger numerator is the greater fraction\n5. 126/630 = 126/630 or 18/90 = 7/35\n\nMathStep (Works offline)", null, "Download our mobile app and learn to work with fractions in your own time:" ]

[ null, "https://answers.everydaycalculation.com/mathstep-app-icon.png", null ]

[ "# #0ca376 Color Information\n\nIn a RGB color space, hex #0ca376 is composed of 4.7% red, 63.9% green and 46.3% blue. Whereas in a CMYK color space, it is composed of 92.6% cyan, 0% magenta, 27.6% yellow and 36.1% black. It has a hue angle of 162.1 degrees, a saturation of 86.3% and a lightness of 34.3%. #0ca376 color hex could be obtained by blending #18ffec with #004700. Closest websafe color is: #009966.\n\n• R 5\n• G 64\n• B 46\nRGB color chart\n• C 93\n• M 0\n• Y 28\n• K 36\nCMYK color chart\n\n#0ca376 color description : Dark cyan - lime green.\n\n# #0ca376 Color Conversion\n\nThe hexadecimal color #0ca376 has RGB values of R:12, G:163, B:118 and CMYK values of C:0.93, M:0, Y:0.28, K:0.36. Its decimal value is 828278.\n\nHex triplet RGB Decimal 0ca376 `#0ca376` 12, 163, 118 `rgb(12,163,118)` 4.7, 63.9, 46.3 `rgb(4.7%,63.9%,46.3%)` 93, 0, 28, 36 162.1°, 86.3, 34.3 `hsl(162.1,86.3%,34.3%)` 162.1°, 92.6, 63.9 009966 `#009966`\nCIE-LAB 59.506, -46.436, 13.555 16.517, 27.579, 21.591 0.251, 0.42, 27.579 59.506, 48.374, 163.727 59.506, -49.786, 25.624 52.515, -35.759, 12.384 00001100, 10100011, 01110110\n\n# Color Schemes with #0ca376\n\n• #0ca376\n``#0ca376` `rgb(12,163,118)``\n• #a30c39\n``#a30c39` `rgb(163,12,57)``\nComplementary Color\n• #0ca32b\n``#0ca32b` `rgb(12,163,43)``\n• #0ca376\n``#0ca376` `rgb(12,163,118)``\n• #0c85a3\n``#0c85a3` `rgb(12,133,163)``\nAnalogous Color\n• #a32b0c\n``#a32b0c` `rgb(163,43,12)``\n• #0ca376\n``#0ca376` `rgb(12,163,118)``\n• #a30c85\n``#a30c85` `rgb(163,12,133)``\nSplit Complementary Color\n• #a3760c\n``#a3760c` `rgb(163,118,12)``\n• #0ca376\n``#0ca376` `rgb(12,163,118)``\n• #760ca3\n``#760ca3` `rgb(118,12,163)``\nTriadic Color\n• #39a30c\n``#39a30c` `rgb(57,163,12)``\n• #0ca376\n``#0ca376` `rgb(12,163,118)``\n• #760ca3\n``#760ca3` `rgb(118,12,163)``\n• #a30c39\n``#a30c39` `rgb(163,12,57)``\nTetradic Color\n• #075c42\n``#075c42` `rgb(7,92,66)``\n• #097354\n``#097354` `rgb(9,115,84)``\n• #0a8b65\n``#0a8b65` `rgb(10,139,101)``\n• #0ca376\n``#0ca376` `rgb(12,163,118)``\n• #0ebb87\n``#0ebb87` `rgb(14,187,135)``\n• #0fd398\n``#0fd398` `rgb(15,211,152)``\n• #11eaaa\n``#11eaaa` `rgb(17,234,170)``\nMonochromatic Color\n\n# Alternatives to #0ca376\n\nBelow, you can see some colors close to #0ca376. Having a set of related colors can be useful if you need an inspirational alternative to your original color choice.\n\n• #0ca350\n``#0ca350` `rgb(12,163,80)``\n• #0ca35d\n``#0ca35d` `rgb(12,163,93)``\n• #0ca369\n``#0ca369` `rgb(12,163,105)``\n• #0ca376\n``#0ca376` `rgb(12,163,118)``\n• #0ca383\n``#0ca383` `rgb(12,163,131)``\n• #0ca38f\n``#0ca38f` `rgb(12,163,143)``\n• #0ca39c\n``#0ca39c` `rgb(12,163,156)``\nSimilar Colors\n\n# #0ca376 Preview\n\nText with hexadecimal color #0ca376\n\nThis text has a font color of #0ca376.\n\n``<span style=\"color:#0ca376;\">Text here</span>``\n#0ca376 background color\n\nThis paragraph has a background color of #0ca376.\n\n``<p style=\"background-color:#0ca376;\">Content here</p>``\n#0ca376 border color\n\nThis element has a border color of #0ca376.\n\n``<div style=\"border:1px solid #0ca376;\">Content here</div>``\nCSS codes\n``.text {color:#0ca376;}``\n``.background {background-color:#0ca376;}``\n``.border {border:1px solid #0ca376;}``\n\n# Shades and Tints of #0ca376\n\nA shade is achieved by adding black to any pure hue, while a tint is created by mixing white to any pure color. In this example, #01110c is the darkest color, while #fefffe is the lightest one.\n\n• #01110c\n``#01110c` `rgb(1,17,12)``\n• #032319\n``#032319` `rgb(3,35,25)``\n• #043527\n``#043527` `rgb(4,53,39)``\n• #054834\n``#054834` `rgb(5,72,52)``\n• #075a41\n``#075a41` `rgb(7,90,65)``\n• #086c4e\n``#086c4e` `rgb(8,108,78)``\n• #097e5c\n``#097e5c` `rgb(9,126,92)``\n• #0b9169\n``#0b9169` `rgb(11,145,105)``\n• #0ca376\n``#0ca376` `rgb(12,163,118)``\n• #0db583\n``#0db583` `rgb(13,181,131)``\n• #0fc890\n``#0fc890` `rgb(15,200,144)``\n• #10da9e\n``#10da9e` `rgb(16,218,158)``\n• #11ecab\n``#11ecab` `rgb(17,236,171)``\nShade Color Variation\n• #22efb2\n``#22efb2` `rgb(34,239,178)``\n• #35f0b8\n``#35f0b8` `rgb(53,240,184)``\n• #47f1bf\n``#47f1bf` `rgb(71,241,191)``\n• #59f3c5\n``#59f3c5` `rgb(89,243,197)``\n• #6bf4cb\n``#6bf4cb` `rgb(107,244,203)``\n• #7ef5d2\n``#7ef5d2` `rgb(126,245,210)``\n• #90f7d8\n``#90f7d8` `rgb(144,247,216)``\n• #a2f8df\n``#a2f8df` `rgb(162,248,223)``\n• #b4fae5\n``#b4fae5` `rgb(180,250,229)``\n• #c7fbeb\n``#c7fbeb` `rgb(199,251,235)``\n• #d9fcf2\n``#d9fcf2` `rgb(217,252,242)``\n• #ebfef8\n``#ebfef8` `rgb(235,254,248)``\n• #fefffe\n``#fefffe` `rgb(254,255,254)``\nTint Color Variation\n\n# Tones of #0ca376\n\nA tone is produced by adding gray to any pure hue. In this case, #565958 is the less saturated color, while #05aa79 is the most saturated one.\n\n• #565958\n``#565958` `rgb(86,89,88)``\n• #4f605b\n``#4f605b` `rgb(79,96,91)``\n• #49665e\n``#49665e` `rgb(73,102,94)``\n• #426d60\n``#426d60` `rgb(66,109,96)``\n• #3b7463\n``#3b7463` `rgb(59,116,99)``\n• #347b66\n``#347b66` `rgb(52,123,102)``\n• #2e8168\n``#2e8168` `rgb(46,129,104)``\n• #27886b\n``#27886b` `rgb(39,136,107)``\n• #208f6e\n``#208f6e` `rgb(32,143,110)``\n• #199671\n``#199671` `rgb(25,150,113)``\n• #139c73\n``#139c73` `rgb(19,156,115)``\n• #0ca376\n``#0ca376` `rgb(12,163,118)``\n• #05aa79\n``#05aa79` `rgb(5,170,121)``\nTone Color Variation\n\n# Color Blindness Simulator\n\nBelow, you can see how #0ca376 is perceived by people affected by a color vision deficiency. This can be useful if you need to ensure your color combinations are accessible to color-blind users.\n\nMonochromacy\n• Achromatopsia 0.005% of the population\n• Atypical Achromatopsia 0.001% of the population\nDichromacy\n• Protanopia 1% of men\n• Deuteranopia 1% of men\n• Tritanopia 0.001% of the population\nTrichromacy\n• Protanomaly 1% of men, 0.01% of women\n• Deuteranomaly 6% of men, 0.4% of women\n• Tritanomaly 0.01% of the population" ]

[ null ]

[ "", null, "Weight = 160 Ton", null, "Weight = 550 Ton", null, "Weight = 200 Ton", null, "Weight = 650 Ton", null, "Weight = 550 Ton", null, "Weight = 850 Ton", null, "Weight = 200 Ton", null, "Weight = 480 Ton", null, "Weight = 350 Ton", null, "Weight = 1100 Ton" ]

[ null, "https://fivemeteors.com/wp-content/uploads/2020/03/galley10-main.jpg", null, "https://fivemeteors.com/wp-content/uploads/2020/03/galley11-main.jpg", null, "https://fivemeteors.com/wp-content/uploads/2020/03/galley12-main.jpg", null, "https://fivemeteors.com/wp-content/uploads/2020/03/galley13-main.jpg", null, "https://fivemeteors.com/wp-content/uploads/2020/03/galley14-main.jpg", null, "https://fivemeteors.com/wp-content/uploads/2020/03/galley15-main.jpg", null, "https://fivemeteors.com/wp-content/uploads/2020/03/galley16-main.jpg", null, "https://fivemeteors.com/wp-content/uploads/2020/03/galley17-main.jpg", null, "https://fivemeteors.com/wp-content/uploads/2020/03/galley18-main.jpg", null, "https://fivemeteors.com/wp-content/uploads/2020/03/galley19-main.jpg", null ]

[ "# pitch\n\nEstimate fundamental frequency of audio signal\n\n## Syntax\n\n``f0 = pitch(audioIn,fs)``\n``f0 = pitch(audioIn,fs,Name,Value)``\n``[f0,loc] = pitch(___)``\n\n## Description\n\nexample\n\n````f0 = pitch(audioIn,fs)` returns estimates of the fundamental frequency over time for the audio input, `audioIn`, with sample rate `fs`. Columns of the input are treated as individual channels.```\n\nexample\n\n````f0 = pitch(audioIn,fs,Name,Value)` specifies options using one or more `Name,Value` pair arguments.```\n\nexample\n\n````[f0,loc] = pitch(___)` returns the locations, `loc`, associated with fundamental frequency estimates.```\n\n## Examples\n\ncollapse all\n\nRead in an audio signal. Call `pitch` to estimate the fundamental frequency over time.\n\n```[audioIn,fs] = audioread('Hey.ogg'); f0 = pitch(audioIn,fs);```\n\nListen to the audio signal and plot the signal and pitch. The `pitch` function returns an estimate of the fundamental frequency over time, but the estimate is only valid for regions that are harmonic.\n\n```sound(audioIn,fs) tiledlayout(2,1) nexttile plot(audioIn) xlabel('Sample Number') ylabel('Amplitude') nexttile plot(f0) xlabel('Frame Number') ylabel('Pitch (Hz)')```", null, "Read in an audio signal and extract the pitch.\n\n```[x,fs] = audioread('singing-a-major.ogg'); t = (0:size(x,1)-1)/fs; winLength = round(0.05*fs); overlapLength = round(0.045*fs); [f0,idx] = pitch(x,fs,'Method','SRH','WindowLength',winLength,'OverlapLength',overlapLength); tf0 = idx/fs;```\n\nListen to the audio and plot the audio and pitch estimations.\n\n```sound(x,fs) figure tiledlayout(2,1) nexttile plot(t,x) ylabel('Amplitude') title('Audio Signal') axis tight nexttile plot(tf0,f0) xlabel('Time (s)') ylabel('Pitch (Hz)') title('Pitch Estimations') axis tight```", null, "The `pitch` function estimates the pitch for overlapped analysis windows. The pitch estimates are only valid if the analysis window has a harmonic component. Call the `harmonicRatio` function using the same window and overlap length used for pitch detection. Plot the audio, pitch, and harmonic ratio.\n\n```hr = harmonicRatio(x,fs,\"Window\",hamming(winLength,'periodic'),\"OverlapLength\",overlapLength); figure tiledlayout(3,1) nexttile plot(t,x) ylabel('Amplitude') title('Audio Signal') axis tight nexttile plot(tf0,f0) ylabel('Pitch (Hz)') title('Pitch Estimations') axis tight nexttile plot(tf0,hr) xlabel('Time (s)') ylabel('Ratio') title('Harmonic Ratio') axis tight```", null, "Use the harmonic ratio as the threshold for valid pitch decisions. If the harmonic ratio is less than the threshold, set the pitch decision to `NaN`. Plot the results.\n\n```threshold = 0.9; f0(hr < threshold) = nan; figure plot(tf0,f0) xlabel('Time (s)') ylabel('Pitch (Hz)') title('Pitch Estimations') grid on```", null, "Read in an audio signal of a female voice saying \"volume up\" five times. Listen to the audio.\n\n```[femaleVoice,fs] = audioread('female-volume-up.ogg'); sound(femaleVoice,fs)```\n\nRead in an audio signal of a male voice saying \"volume up\" five times. Listen to the audio.\n\n```maleVoice = audioread('male-volume-up.ogg'); sound(maleVoice,fs)```\n\nExtract the pitch from both the female and male recordings. Plot histograms of the pitch estimations for the male and female audio recordings. The histograms have a similar shape. This is because the pitch decisions contain results for unvoiced speech and regions of silence.\n\n```f0Female = pitch(femaleVoice,fs); f0Male = pitch(maleVoice,fs); figure numBins = 20; histogram(f0Female,numBins,\"Normalization\",\"probability\"); hold on histogram(f0Male,numBins,\"Normalization\",\"probability\"); legend('Female Voice','Male Voice') xlabel('Pitch (Hz)') ylabel('Probability') hold off```", null, "Use the `detectSpeech` function to isolate regions of speech in the audio signal and then extract pitch from only those speech regions.\n\n```speechIndices = detectSpeech(femaleVoice,fs); f0Female = []; for ii = 1:size(speechIndices,1) speechSegment = femaleVoice(speechIndices(ii,1):speechIndices(ii,2)); f0Female = [f0Female;pitch(speechSegment,fs)]; end speechIndices = detectSpeech(maleVoice,fs); f0Male = []; for ii = 1:size(speechIndices,1) speechSegment = maleVoice(speechIndices(ii,1):speechIndices(ii,2)); f0Male = [f0Male;pitch(speechSegment,fs)]; end```\n\nPlot histograms of the pitch estimations for the male and female audio recordings. The pitch distributions now appear as expected.\n\n```figure histogram(f0Female,numBins,\"Normalization\",\"probability\"); hold on histogram(f0Male,numBins,\"Normalization\",\"probability\"); legend('Female Voice','Male Voice') xlabel('Pitch (Hz)') ylabel('Probability')```", null, "Load an audio file of the Für Elise introduction and the sample rate of the audio.\n\n```load FurElise.mat song fs sound(song,fs)```\n\nCall the `pitch` function using the pitch estimate filter (`PEF`), a search range of 50 to 800 Hz, a window duration of 80 ms, an overlap duration of 70 ms, and a median filter length of 10. Plot the results.\n\n```method =", null, "\"PEF\"; range = [", null, "50,", null, "800]; % hertz winDur =", null, "0.08; % seconds overlapDur =", null, "0.07; % seconds medFiltLength =", null, "10; % frames winLength = round(winDur*fs); overlapLength = round(overlapDur*fs); [f0,loc] = pitch(song,fs, ... 'Method',method, ... 'Range',range, ... 'WindowLength',winLength, ... 'OverlapLength',overlapLength, ... \"MedianFilterLength\",medFiltLength); t = loc/fs; plot(t,f0) ylabel('Pitch (Hz)') xlabel('Time (s)') grid on```", null, "Create a `dsp.AudioFileReader` object to read in audio frame-by-frame.\n\n`fileReader = dsp.AudioFileReader('singing-a-major.ogg');`\n\nCreate a `voiceActivityDetector` object to detect the presence of voice in streaming audio.\n\n`VAD = voiceActivityDetector;`\n\nWhile there are unread samples, read from the file and determine the probability that the frame contains voice activity. If the frame contains voice activity, call `pitch` to estimate the fundamental frequency of the audio frame. If the frame does not contain voice activity, declare the fundamental frequency as `NaN`.\n\n```f0 = []; while ~isDone(fileReader) x = fileReader(); if VAD(x) > 0.99 decision = pitch(x,fileReader.SampleRate, ... \"WindowLength\",size(x,1), ... \"OverlapLength\",0, ... \"Range\",[200,340]); else decision = NaN; end f0 = [f0;decision]; end```\n\nPlot the detected pitch contour over time.\n\n```t = linspace(0,(length(f0)*fileReader.SamplesPerFrame)/fileReader.SampleRate,length(f0)); plot(t,f0) ylabel('Fundamental Frequency (Hz)') xlabel('Time (s)') grid on```", null, "The different methods of estimating pitch provide trade-offs in terms of noise robustness, accuracy, optimal lag, and computation expense. In this example, you compare the performance of different pitch detection algorithms in terms of gross pitch error (GPE) and computation time under different noise conditions.\n\nPrepare Test Signals\n\nLoad an audio file and determine the number of samples it has. Also load the true pitch corresponding to the audio file. The true pitch was determined as an average of several third-party algorithms on the clean speech file.\n\n```[audioIn,fs] = audioread('Counting-16-44p1-mono-15secs.wav'); numSamples = size(audioIn,1); load TruePitch.mat truePitch```\n\nCreate test signals by adding noise to the audio signal at given SNRs. The `mixSNR` function is a convenience function local to this example, which takes a signal, noise, and requested SNR and returns a noisy signal at the request SNR.\n\n```testSignals = zeros(numSamples,4); turbine = audioread('Turbine-16-44p1-mono-22secs.wav'); testSignals(:,1) = mixSNR(audioIn,turbine,20); testSignals(:,2) = mixSNR(audioIn,turbine,0); whiteNoiseMaker = dsp.ColoredNoise('Color','white','SamplesPerFrame',size(audioIn,1)); testSignals(:,3) = mixSNR(audioIn,whiteNoiseMaker(),20); testSignals(:,4) = mixSNR(audioIn,whiteNoiseMaker(),0);```\n\nSave the noise conditions and algorithm names as cell arrays for labeling and indexing.\n\n```noiseConditions = {'Turbine (20 dB)','Turbine (0 dB)','WhiteNoise (20 dB)','WhiteNoise (0 dB)'}; algorithms = {'NCF','PEF','CEP','LHS','SRH'};```\n\nRun Pitch Detection Algorithms\n\nPreallocate arrays to hold pitch decisions for each algorithm and noise condition pair, and the timing information. In a loop, call the `pitch` function on each combination of algorithm and noise condition. Each algorithm has an optimal window length associated with it. In this example, for simplicity, you use the default window length for all algorithms. Use a 3-element median filter to smooth the pitch decisions.\n\n```f0 = zeros(numel(truePitch),numel(algorithms),numel(noiseConditions)); algorithmTimer = zeros(numel(noiseConditions),numel(algorithms)); for k = 1:numel(noiseConditions) x = testSignals(:,k); for i = 1:numel(algorithms) tic f0temp = pitch(x,fs, ... 'Range',[50 300], ... 'Method',algorithms{i}, ... 'MedianFilterLength',3); algorithmTimer(k,i) = toc; f0(1:max(numel(f0temp),numel(truePitch)),i,k) = f0temp; end end```\n\nCompare Gross Pitch Error\n\nGross pitch error (GPE) is a popular metric when comparing pitch detection algorithms. GPE is defined as the proportion of pitch decisions for which the relative error is higher than a given threshold, traditionally 20% in speech studies. Calculate the GPE and print it to the Command Window.\n\n```idxToCompare = ~isnan(truePitch); truePitch = truePitch(idxToCompare); f0 = f0(idxToCompare,:,:); p = 0.20; GPE = mean( abs(f0(1:numel(truePitch),:,:) - truePitch) > truePitch.*p).*100; for ik = 1:numel(noiseConditions) fprintf('\\nGPE (p = %0.2f), Noise = %s.\\n',p,noiseConditions{ik}); for i = 1:size(GPE,2) fprintf('- %s : %0.1f %%\\n',algorithms{i},GPE(1,i,ik)) end end```\n```GPE (p = 0.20), Noise = Turbine (20 dB). ```\n```- NCF : 0.9 % - PEF : 0.4 % - CEP : 8.2 % - LHS : 8.2 % - SRH : 6.0 % ```\n```GPE (p = 0.20), Noise = Turbine (0 dB). ```\n```- NCF : 5.6 % - PEF : 24.5 % - CEP : 11.6 % - LHS : 9.4 % - SRH : 46.8 % ```\n```GPE (p = 0.20), Noise = WhiteNoise (20 dB). ```\n```- NCF : 0.9 % - PEF : 0.0 % - CEP : 12.9 % - LHS : 6.9 % - SRH : 2.6 % ```\n```GPE (p = 0.20), Noise = WhiteNoise (0 dB). ```\n```- NCF : 0.4 % - PEF : 0.0 % - CEP : 23.6 % - LHS : 7.3 % - SRH : 1.7 % ```\n\nCalculate the average time it takes to process one second of data for each of the algorithms and print the results.\n\n```aT = sum(algorithmTimer)./((numSamples/fs)*numel(noiseConditions)); for ik = 1:numel(algorithms) fprintf('- %s : %0.3f (s)\\n',algorithms{ik},aT(ik)) end```\n```- NCF : 0.035 (s) - PEF : 0.112 (s) - CEP : 0.037 (s) - LHS : 0.049 (s) - SRH : 0.095 (s) ```\n\n## Input Arguments\n\ncollapse all\n\nAudio input signal, specified as a vector or matrix. The columns of the matrix are treated as individual audio channels.\n\nData Types: `single` | `double`\n\nSample rate of the input signal in Hz, specified as a positive scalar.\n\nThe sample rate must be greater than or equal to twice the upper bound of the search range. Specify the search range using the `Range` name-value pair.\n\nData Types: `single` | `double`\n\n### Name-Value Arguments\n\nSpecify optional comma-separated pairs of `Name,Value` arguments. `Name` is the argument name and `Value` is the corresponding value. `Name` must appear inside quotes. You can specify several name and value pair arguments in any order as `Name1,Value1,...,NameN,ValueN`.\n\nExample: `pitch(audioIn,fs,'Range',[50,150],'Method','PEF')`\n\nSearch range for pitch estimates, specified as the comma-separated pair consisting of 'Range' and a two-element row vector with increasing positive integer values. The function searches for a best estimate of the fundamental frequency within the upper and lower band edges specified by the vector, according to the algorithm specified by `Method`. The range is inclusive and units are in Hz.\n\nValid values for the search range depend on the sample rate, `fs`, and on the values of `WindowLength` and `Method`:\n\nMethodMinimum RangeMaximum Range\n'`NCF`'```fs/WindowLength < Range(1)``````Range(2) < fs/2```\n'`PEF`'`10 < Range(1)````Range(2) < min(4000,fs/2)```\n'`CEP`'```fs/(2^nextpow2(2*WindowLength-1)) < Range(1)``````Range(2) < fs/2```\n'`LHS`'`1 < Range(1)````Range(2) < fs/5 - 1```\n'`SRH`'`1 < Range(1)````Range(2) < fs/5 - 1```\n\nData Types: `single` | `double`\n\nNumber of samples in the analysis window, specified as the comma-separated pair consisting of '`WindowLength`' and an integer in the range [1, min(size(`audioIn`,1), 192000)]. Typical analysis windows are in the range 20–100 ms. The default window length is 52 ms.\n\nData Types: `single` | `double`\n\nNumber of samples of overlap between adjacent analysis windows, specified as the comma-separated pair consisting of '`OverlapLength`' and an integer in the range (`-inf`,`WindowLength`). A negative overlap length indicates non-overlapping analysis windows.\n\nData Types: `single` | `double`\n\nMethod used to estimate pitch, specified as the comma-separated pair consisting of '`Method`' and `'NCF'`, `'PEF'`,`'CEP'`, `'LHS'`, or `'SRH'`. The different methods of calculating pitch provide trade-offs in terms of noise robustness, accuracy, and computation expense. The algorithms used to calculate pitch are based on the following papers:\n\n• `'NCF'` –– Normalized Correlation Function \n\n• `'PEF'` –– Pitch Estimation Filter . The function does not use the amplitude compression described by the paper.\n\n• `'CEP'` –– Cepstrum Pitch Determination \n\n• `'LHS'` –– Log-Harmonic Summation \n\n• `'SRH'` –– Summation of Residual Harmonics \n\nData Types: `char` | `string`\n\nMedian filter length used to smooth pitch estimates over time, specified as the comma-separated pair consisting of '`MedianFilterLength`' and a positive integer. The default, `1`, corresponds to no median filtering. Median filtering is a postprocessing technique used to remove outliers while estimating pitch. The function uses `movmedian` after estimating the pitch using the specified `Method`.\n\nData Types: `single` | `double`\n\n## Output Arguments\n\ncollapse all\n\nEstimated fundamental frequency, in Hz, returned as a scalar, vector, or matrix. The number of rows returned depends on the values of the `WindowLength` and `OverlapLength` name-value pairs, and on the input signal size. The number of columns (channels) returned depends on the number of columns of the input signal size.\n\nData Types: `single` | `double`\n\nLocations associated with fundamental frequency estimations, returned as a scalar, vector, or matrix the same size as `f0`.\n\nFundamental frequency is estimated locally over a region of `WindowLength` samples. The values of `loc` correspond to the most recent sample (largest sample number) used to estimate fundamental frequency.\n\nData Types: `single` | `double`\n\n## Algorithms\n\nThe `pitch` function segments the audio input according to the `WindowLength` and `OverlapLength` arguments. The fundamental frequency is estimated for each frame. The locations output, `loc` contains the most recent samples (largest sample numbers) of the corresponding frame.", null, "For a description of the algorithms used to estimate the fundamental frequency, consult the corresponding references:\n\n• `'NCF'` –– Normalized Correlation Function \n\n• `'PEF'` –– Pitch Estimation Filter . The function does not use the amplitude compression described by the paper.\n\n• `'CEP'` –– Cepstrum Pitch Determination \n\n• `'LHS'` –– Log-Harmonic Summation \n\n• `'SRH'` –– Summation of Residual Harmonics \n\n Atal, B.S. \"Automatic Speaker Recognition Based on Pitch Contours.\" The Journal of the Acoustical Society of America. Vol. 52, No. 6B, 1972, pp. 1687–1697.\n\n Gonzalez, Sira, and Mike Brookes. \"A Pitch Estimation Filter robust to high levels of noise (PEFAC).\" 19th European Signal Processing Conference. Barcelona, 2011, pp. 451–455.\n\n Noll, Michael A. \"Cepstrum Pitch Determination.\" The Journal of the Acoustical Society of America. Vol. 31, No. 2, 1967, pp. 293–309.\n\n Hermes, Dik J. \"Measurement of Pitch by Subharmonic Summation.\" The Journal of the Acoustical Society of America. Vol. 83, No. 1, 1988, pp. 257–264.\n\n Drugman, Thomas, and Abeer Alwan. \"Joint Robust Voicing Detection and Pitch Estimation Based on Residual Harmonics.\" Proceedings of the Annual Conference of the International Speech Communication Association, INTERSPEECH. 2011, pp. 1973–1976.\n\n## Support", null, "평가판 신청" ]

[ null, "https://kr.mathworks.com/help/examples/audio/win64/EstimatePitchOfSpeechSignalUsingDefaultParametersExample_01.png", null, "https://kr.mathworks.com/help/examples/audio/win64/EstimatePitchForSingingVoiceExample_01.png", null, "https://kr.mathworks.com/help/examples/audio/win64/EstimatePitchForSingingVoiceExample_02.png", null, "https://kr.mathworks.com/help/examples/audio/win64/EstimatePitchForSingingVoiceExample_03.png", null, "https://kr.mathworks.com/help/examples/audio/win64/ComparePitchOfTwoVoicesExample_01.png", null, "https://kr.mathworks.com/help/examples/audio/win64/ComparePitchOfTwoVoicesExample_02.png", null, "https://kr.mathworks.com/help/examples/audio/win64/EstimatePitchOfMusicalSignalUsingNondefaultParametersExample_02.png", null, "https://kr.mathworks.com/help/examples/audio/win64/EstimatePitchOfMusicalSignalUsingNondefaultParametersExample_03.png", null, "https://kr.mathworks.com/help/examples/audio/win64/EstimatePitchOfMusicalSignalUsingNondefaultParametersExample_04.png", null, "https://kr.mathworks.com/help/examples/audio/win64/EstimatePitchOfMusicalSignalUsingNondefaultParametersExample_05.png", null, "https://kr.mathworks.com/help/examples/audio/win64/EstimatePitchOfMusicalSignalUsingNondefaultParametersExample_06.png", null, "https://kr.mathworks.com/help/examples/audio/win64/EstimatePitchOfMusicalSignalUsingNondefaultParametersExample_07.png", null, "https://kr.mathworks.com/help/examples/audio/win64/EstimatePitchOfMusicalSignalUsingNondefaultParametersExample_01.png", null, "https://kr.mathworks.com/help/examples/audio/win64/DeterminePitchContourUsingPitchAndVoiceActivityDetectorExample_01.png", null, "https://kr.mathworks.com/help/audio/ref/pitch_segmentation.png", null, "https://kr.mathworks.com/images/responsive/supporting/apps/doc_center/bg-trial-arrow.png", null ]

[ "## Henry's law\n\nhttps://doi.org/10.1351/goldbook.H02783\nThe partial pressure (fugacity) of a solute (B) in a solution is directly proportional to the rational chemical activity (ax) of the solute; this relationship is called Henry's law: $p_{\\text{B}}=\\frac{a_{x,\\text{B}}}{\\alpha _{x,\\text{B}}^{\\infty }}$ where a∞x,B is the rational solubility coefficient for infinite dilution, i.e. for pure solvent. For the solvent (A) the relationship is called Raoult's law, and the proportionality factor is the fugacity of the pure solvent, p(~)A∗: $p_{\\text{A}}=\\overset{˜}{p}_{\\text{A}}^{\\ast }\\ a_{\\text{A}}$\nSource:\nPAC, 1984, 56, 567. 'Physicochemical quantities and units in clinical chemistry with special emphasis on activities and activity coefficients (Recommendations 1983)' on page 571 (https://doi.org/10.1351/pac198456050567)" ]

[ null ]

[ "# Constructive Mathematics\n\nConstructive mathematics is positively characterized by the requirement that proof be algorithmic. Loosely speaking, this means that when a (mathematical) object is asserted to exist, an explicit example is given: a constructive existence proof demonstrates the existence of a mathematical object by outlining a method of finding (“constructing”) such an object. The emphasis in constructive theory is placed on hands-on provability, instead of on an abstract notion of truth. The classical concept of validity is starkly contrasted with the constructive notion of proof. An implication (A⟹B) is not equivalent to a disjunction (¬A∨B), and neither are equivalent to a negated conjunction (¬(A∧¬B)). In practice, constructive mathematics may be viewed as mathematics done using intuitionistic logic.\n\nWith the advent of the computer, much more emphasis has been placed on algorithmic procedures for obtaining numerical results, and constructive mathematics has come into its own. For, a constructive proof is exactly that: an algorithmic procedure for obtaining a conclusion from a set of hypotheses.\n\nThe historical and philosophical picture is complex; various forms of constructivism have developed over time. Presented here is a brief introduction to several of the more widely accepted approaches, and is by no means comprehensive.\n\n## 1. Motivation and History\n\nThe origin of modern constructive mathematics lies in the foundational debate at the turn of the 20th Century. At that time, the German mathematician David Hilbert established some very deep and far-reaching existence theorems using non-constructive methods. Around the same time, the Dutch mathematician L.E.J. Brouwer became philosophically convinced that the universal validity of contradiction proofs for existence proofs was unwarranted—despite his early work in establishing the non-constructive fixed point theorem which now bears his name.\n\nIt is often the case that a classical theorem becomes more enlightening when seen from the constructive viewpoint (we meet an example of such a case—the least upper bound principle—in Section 1d. It would, however, be unfair to say that constructive mathematics is revisionist in nature. Indeed, Brouwer proved his Fan Theorem (see Section 2b) intuitionistically in 1927 (Brouwer, 1927), but the first proof of König’s Lemma (its classical equivalent) only appeared in 1936 (König, 1936). It is ironic that the Brouwer’s intuitionist position (see Section 2) has become known as anti-realist since it demands that every object be explicitly constructible.\n\n### a. An example\n\nHere is an example of a non-constructive proof that is commonly encountered in the literature:\n\nProposition.", null, "", null, "The proof is non-constructive because even though it shows that the non-existence of such numbers would be contradictory, it leaves us without the knowledge of which choice of a$a$ and b$b$ satisfy the theorem. There is a (simple) constructive proof of this theorem: set a=2$a=sqrt{2}$ and b=log29$b = log_2{9}$ (in the full constructive proof, a little work first needs to be done to demonstrate that a$a$ and b$b$ are, in fact, irrational). A fully constructive proof that 2$sqrt{2}$ is properly irrational (that is, positively bounded away from every rational number) may be found in Bishop (1973). This clarifies the choice of words in the proposition above. It is further possible to show that 22$sqrt{2}^{sqrt{2}}$ is in fact irrational, but this is not done by the proof presented here. (An early mention of the above illustrative example in the literature is in Dummett (1977, p. 10).)\n\n### b. Constructivism as philosophy\n\nConstructive mathematics is often mis-characterized as classical mathematics without the axiom of choice (see Section 1f); or classical mathematics without the Law of Excluded Middle. But seen from within the discipline, constructive mathematics is positively characterized by a strict provability requirement. The consequences of adopting this stance—and rigorously implementing it—are far-reaching, as will be seen.\n\nThere are two conditions which are fundamental to every constructivist philosophy:\n\n• The notion of truth’ is not taken as primitive; rather, a proposition is considered true only when a proof for the proposition is produced.\n• The notion of existence’ is taken to be constructibility: when an object is proved to exist, the proof also exhibits how to find it.\n\nTo assert that P$P$, then, is to produce a proof that P$P$. Likewise, to assert that ¬P$neg P$ is to prove that the assumption of P$P$ leads to a contradiction. Very quickly, one realizes that the Principle of Excluded Middle (PEM; Latin tertium non datur or principium tertii exclusi) leads to trouble:\n\nPEM: For any statement P$P$, either P$P$ or ¬P$neg P$.\n\nThe assertion of PEM constructively amounts to claiming that, for any given statement P$P$, either there is a proof of P$P$, or there is a proof that P$P$ leads to a contradiction. Consider, for example, the following:\n\nThe Collatz conjecture. Define f:NN$f:mathbb{N} to mathbb{N}$ by the rule:\n\nf(n)={n/23n+1if n is even,if n is odd.\n\nThen for each natural number n$n$, that is for each n in {1,2,3,…}, there exists a natural number k$k$ such that fk(n)=1$f^k(n) = 1$.\n\nAt the time of writing this article, the Collatz conjecture remains unsolved. To claim that there is a proof of it is erroneous; likewise to claim that there is a proof that it leads to a contradiction is also erroneous. In fact, in Brouwer’s view (see Section 2), to assert PEM is to claim that any mathematical problem has a solution. Thus there are good philosophical grounds for rejecting PEM.\n\n### c. The BHK interpretation\n\nThe following interpretation of logical connectives is now known as the Brouwer-Heyting-Kolmogorov (BHK) interpretation, and is widely accepted by constructivists.\n\n Statement Interpretation P$P$ We have a proof of P$P$. P∧Q$P land Q$ We have both a proof of P$P$ and a proof of Q$Q$. P∨Q$P lor Q$ We have either a proof of P$P$ or a proof of Q$Q$. P⟹Q$P implies Q$ We have an algorithm that converts any proof of P$P$ into a proof of Q$Q$. ¬P$neg P$ We have a proof that P⟹⊥$P implies bot$, where ⊥$bot$ is absurd (for example, 0=1$0=1$). ∃x∈AP(x)$exists_{x in A}P(x)$ We have an algorithm which computes an object x∈A$x in A$ and confirms that P(x)$P(x)$. ∀x∈AP(x)$forall_{x in A}P(x)$ We have an algorithm which, given any object x$x$, together with the data that x∈A$x in A$, shows that P(x)$P(x)$ holds.\n\nIn particular, the interpretations for ¬,,$neg, lor, implies$ and $exists$ are worth emphasizing: each of these has the very strict requirement that a proof of such a statement will consist of a decision procedure—in other words, every constructive proof contains, in principle, an algorithm.\n\nThe BHK interpretation characterizes a logic called intuitionistic logic. Every form of constructive mathematics has intuitionistic logic at its core; different schools have different additional principles or axioms given by the particular approach to constructivism.\n\n### d. Constructive methods in mathematics\n\nUpon adopting only constructive methods, we lose some powerful proof tools commonly used in classical mathematics. We have already seen that the Principle of Excluded Middle is highly suspect from the constructivist viewpoint, as (under the BHK interpretation) it claims the existence of a universal algorithm to determine the truth of any given statement. This is not to say that PEM is constructively false, however. Both Russian recursive mathematics (in which PEM is provably false) and classical mathematics (in which it is logically true) are in a sense models, or interpretations, of constructive mathematics. So in a way, PEM is independent of constructive mathematics. Note, however, that if one is given a statement, it may be possible to prove PEM concerning that particular statement—such statements are called decidable. The point is that there is no general constructive method for doing so for all statements.\n\nIf PEM is not universally valid we also lose universal applicability of any mode of argument which validates it. For example, double negation elimination, or proof by contradiction. Again, it must be emphasized that it is only the universal applicability which is challenged: proof by contradiction is constructively just fine for proving negative statements; and double negation elimination is just fine for decidable statements.\n\nHowever these limitations are in fact often advantages. In a lot of cases, constructive alternatives to non-constructive classical principles in mathematics exist, leading to results which are often constructively stronger than their classical counterpart. For example, the classical least upper bound principle (LUB) is not constructively provable:\n\nLUB: Any nonempty set of real numbers that is bounded from above has a least upper bound.\n\nThe constructive least upper bound principle, by contrast, is constructively provable (Bishop & Bridges, 1985, p. 37):\n\nCLUB: Any order-located nonempty set of reals that is bounded from above has a least upper bound.\n\nA set is order-located if given any real x$x$, the distance from x$x$ to the set is computable.\nIt is quite common for a constructive alternative to be classically equivalent to the classical principle; and, indeed, classically every nonempty set of reals is order-located.\n\nTo see why LUB is not provable, we may consider a so-called Brouwerian counterexample (see Section 2a), such as the set\n\nS={xR:(x=2)(x=3P)}\n\nwhere P$P$ is some as-yet unproven statement, such as Goldbach’s conjecture that every even number greater than 2 is the sum of two prime numbers. (There may be some philosophical problems with this set; however these do not matter for the purpose of this example. Section 2a has a much “cleaner”, though more technically involved, example.) If the set S$S$ had a computable least upper bound, then we would have a quick proof of the truth or falsity of Goldbach’s conjecture. A Brouwerian counterexample is an example which shows that if a certain property holds, then it is possible to constructively prove a non-constructive principle (such as PEM); and thus the property itself must be essentially non-constructive.\n\n### e. Early history\n\nIn the late 19th century, the mathematical community embarked on a search for foundations: unquestionable solid ground on which mathematical theorems could be proved. An early exemplar of this search is Kronecker’s 1887 paper “Über den Zahlbegriff” (“On the Concept of Number”) (Kronecker, 1887), where he outlines the project of arithmetization (that is, founding on the fundamental notion of number) of analysis and algebra. It is perhaps in this work that we see the earliest instance of the constructive manifesto in mathematical practice. Kronecker was famously quoted by Weber (1893) as saying “Die ganzen Zahlen hat der liebe Gott gemacht, alles andere ist Menschenwerk.” (“The integers were made by God; all else is the work of man.”)\n\nIt has been said that “almost all mathematical proofs before 1888 were essentially constructive.” (Beeson, 1985, p. 418). This is not to say that constructive mathematics, as currently conceived of, was common practice; but rather that the natural interpretation of existence of the time was existence in the constructive sense. As mathematical concepts have changed over time, however, old proofs have taken on new meaning. There are thus plenty of examples of results which are today regarded as essentially non-constructive, but seen within the context of the period during which they were written, the objects of study that the authors had in mind allowed proofs of a constructive nature. One good example of this is Cauchy’s 1821 proof of the Intermediate Value Theorem (Cauchy, 1821; in Bradley & Sandifer, 2009, pp. 309–312); the classical interval-halving argument. The concept of “function” has, since then, expanded to include objects which allow for Brouwerian counterexamples (see Section 2a).\n\nThe first major systematic development of a constructive approach to mathematics is that of Brouwer and the intuitionists, introduced in the next major section. Some notable forerunners (who should perhaps not be thought of as intuitionists themselves) were Henri Poincaré, who argued that mathematics is in a way more immediate than logic, and Emile Borel, who maintained that the only objects that concern science are those that can be effectively defined (Borel, 1914). Poincaré argues that intuition is a necessary component of mathematical thought, rejects the idea of an actual infinite, and argues that mathematical induction is an unprovable fact (Poincaré, 1908).\n\nAs a result of techniques from ZF set theory, rigorous proofs have over time taken on non-constructive aspects. David Hilbert, contemporary of Brouwer and an opponent of Brouwer’s philosophy, deserves particular mention, since he was an early pioneer of highly non-constructive techniques. The debate between Brouwer and Hilbert grew fierce and controversial, which perhaps added fuel to the development of both constructivism (à la Brouwer) and formalism (à la Hilbert) (see, for example, van Heijenoort, 1976). The spectacular 1890 proof by Hilbert of his famous basis theorem (Hilbert, 1890), showing the existence of a finite set of generators for the invariants of quantics, was greeted by the German mathematician Gordan with another now-(in)famous phrase: “Das ist nicht Mathematik. Das ist Theologie.” (“That is not Mathematics. That is Theology.”) This is perhaps the most dramatic example of a non-constructive proof, relying on PEM in an infinite extension.\n\nThe method Hilbert exhibited there has become widely accepted by the mathematics community as a pure existence proof (that is, proving that non-existence of such an object was contradictory without actually exhibiting the object); however it was not admissible as a constructive technique. Weyl, one of Hilbert’s students (who Hilbert would eventually “lose”—perhaps temporarily—to intuitionism) commented on pure existence proofs, that they “inform the world that a treasure exists without disclosing its location” (Weyl, 1946). The Axiom of Choice, perhaps due in part to its regular use in many non-constructive proofs (and heavily implicated in many of Hilbert’s most influential proofs), has been accused of being the source of non-constructivity in mathematics.\n\n### f. The Axiom of Choice\n\nThe Axiom of Choice (AC) has been controversial to varying degrees in mathematics ever since it was recognized by Zermelo (1904). Loosely, it states that given a collection of non-empty sets, we can choose exactly one item from each set.\n\nAC: If to each x$x$ in A$A$ there corresponds a y$y$ in B$B$, then there is a function f$f$ such that f(x)$f(x)$ is in B$B$ whenever x$x$ is in A$A$.\n\nFormally, given non-empty sets A$A$ and B$B$, the Axiom may be stated as:\n\nxAyBP(x,y)fBAxAP(x,f(x)).\n\nIntuitively, this seems almost trivial, and the case where the non-empty sets are finite in size is indeed so, since one does not need the axiom of choice to prove that such a choice can be made in most formulations of set theory. However it becomes less clear when the size of the sets involved is very large or somehow not easily determined. In such cases, a principled, functional choice may not necessarily be made. Even in classical mathematics, the axiom of choice is occasionally viewed with some suspicion: it leads to results that are surprising and counterintuitive, such as the Banach-Tarski paradox: using the axiom of choice allows one to take a solid sphere in 3-dimensional space, decompose it into a finite number of non-overlapping pieces, and reassemble the pieces (using only rotations and translations) into two solid spheres, each with volume identical to the original sphere. Due to its controversial nature, many mathematicians will explicitly state when and where in their proof AC has been used.\n\nNonetheless, the BHK interpretation of the quantifiers seems to invite one to think about the existential quantifier yB$exists_{y in B}$ as defining the choice function, and so it would seem very natural to adopt AC from the constructive point of view (see, however, the discussion in Sections 4b and 5a). But consider the set S$S$ given by\n\nS={xZ:(x=0P)(x=1¬P)}\n\nfor some syntactically correct statement P$P$. This set is not empty, since if it were then both P$P$ and ¬P$neg P$ would have to be false; so ¬P¬¬P$neg P land negneg P$, a contradiction. Similarly, S$S$ cannot contain both 0$0$ and 1$1$. But suppose that we had an algorithmic procedure which (in a finite time) returns an element of S$S$ for us. If it returns 0$0$, then we know that P$P$ must be true; whereas if it returns 1$1$ then we know that P$P$ must be false—and thus we will have proved that P¬P$P lor neg P$. We may repeat this for any statement, and so this amounts to a (constructive) proof of the universal applicability of PEM. And as we have seen, universal applicability of PEM is not constructively acceptable. Thus, while the set S$S$ is non-empty, we cannot necessarily exhibit any of its members either. A set which has constructible members is called inhabited, and the distinction between inhabited and non-empty sets is key in constructive set theories. Related is the issue of the size of S$S$; since S$S$ is not empty, its size is not 0$0$, but since S$S$ is not (necessarily) inhabited, its size is no other natural number either—S$S$ is an at-most-singleton set. It is a consquence of AC, in fact, that every non-empty set is inhabited.\n\nIt is no coincidence that the symbolic form of AC suggests that it is essentially a quantifier swap: AC states that if to each element of A$A$ an element of B$B$ can be assigned, then it can be done so in a systematic (algorithmic) way. It is thus a kind of uniformity principle.\n\nThe example set S$S$ above is known as a Brouwerian example (although most of Brouwer’s examples of this sort were a little more specific—see below). It is to intuitionism, Brouwer’s philosophy of mathematics, that we now turn.\n\n## 2. Intuitionism\n\nIf there is a name synonymous with constructive mathematics, it is L.E.J. Brouwer (Luitzen Egbertus Jan Brouwer; Bertus to his friends). In his doctoral thesis, Over de Grondslagen der Wiskunde (On the Foundations of Mathematics; Brouwer, 1907), Brouwer began his program of laying the foundations of constructive mathematics in a systematic way. Brouwer’s particular type of constructive mathematics is called “intuitionism” or “intuitionistic mathematics” (not to be confused with intuitionistic logic; recall Section 1c).\n\nShortly after the presentation of his thesis, Brouwer wrote a paper entitled “De onbetrouwbaarheid der logische principes” (“The Untrustworthiness of the Principles of Logic”; Brouwer, 1908), in which he challenged the absolute validity of classical logic: “De vraag naar de geldigheid van het principium tertii exclusi is dus aequivalent met de vraag naar de mogelijkheid van onoplosbare wiskundige problemen.” (“The question of validity of the principle of excluded third is equivalent to the question of the possibility of unsolvable mathematical problems.”; Brouwer, 1908, p. 156) In other words, PEM is valid only if there are no unsolvable mathematical problems.\n\nIn intuitionistic mathematics, mathematics is seen as a free creation of the human mind: a (mathematical) object exists just in case it can be (mentally) constructed. This immediately justifies the BHK interpretation, since any existence proof cannot be a proof-by-contradiction—the contradiction leaves us without a construction of the object.\n\nAccording to Brouwer, the natural numbers and (perhaps surprisingly) the continuum, are primitive notions given directly by intuition alone. This connects to the idea of what Brouwer called free choice sequence, a generalization of the notion of sequence. It is perhaps ironic that when Brouwer initially encountered the idea of a free choice sequence, which had been a mathematical curiosity at the time, he rejected such sequences as non-intuitionistic (Brouwer, 1912). However, soon afterward he accepted them and was the first to discover how important they were to practical constructive mathematics (Brouwer, 1914). This is one of two major aspects which distinguishes intuitionistic mathematics from other kinds of constructive mathematics (the second being Brouwer’s technique of bar induction, which we do not explain in great depth here; though see Section 2b).\n\nA free choice sequence is given by a constructing agent (Brouwer’s creative subject), who is at any stage of the progression of a sequence free to choose (or subject to mild restrictions) the next member of the sequence. For example, if one is asked to produce a binary free choice sequence, one may start “0000$000…0$” for a hundred digits, and then (perhaps unexpectedly) freely choose “1$1$” as the next digit. A real number, classically thought of as a (converging) Cauchy sequence, thus need not be given by a determinate rule; instead, it is only subject to a Cauchy restriction (that is, some rate of convergence).\n\nThe idea of a free choice sequence leads to some very strong commitments. Not immediately obvious is the principle of continuous choice. It states:\n\nIf PNN×N$P subseteq mathbb{N}^mathbb{N} times mathbb{N}$ and for each x$x$ in NN$mathbb{N}^mathbb{N}$ there exists n$n$ in N$mathbb{N}$ such that (x,n)$(x,n)$ is in P$P$, then there is a choice function f:NNN$f:mathbb{N}^mathbb{N} to mathbb{N}$ such that (x,f(x))$(x,f(x))$ is in P$P$ for all x$x$ in NN$mathbb{N}^mathbb{N}$.\n\nThe notation BA$B^A$, where A$A$ and B$B$ are sets, denotes the collection of functions from A$A$ to B$B$. So NN$mathbb{N}^mathbb{N}$ denotes the collection of functions from natural numbers to natural numbers; the arguments x$x$ in question are thus actually functions x:NN$x:mathbb{N} to mathbb{N}$. One may conceive of these (as Brouwer did) as sequences of natural numbers; further technical details are omitted.\n\nIntuitively, the principle arises from the following considerations. Let PNN×N$P subseteq mathbb{N}^mathbb{N} times mathbb{N}$ and suppose that we have a procedure that we may apply to any given sequence x=x1,x2,x3,$x= x_1,x_2,x_3,…$ of natural numbers which computes an index n$n$ such that (x,n)P$(x,n) in P$—that is, P$P$ is a set in which every sequence of natural numbers is (constructively) paired with some natural number. Under the intuitionist’s view, at any given moment we may have only a finite number of terms of x$x$ at hand. The procedure which computes n$n$ such that (x,n)P$(x,n) in P$ must thus do so after being given only a finite initial fragment of x$x$; say x1,x2,,xm$x_1,x_2,…,x_m$. Now if we are given another sequence y$y$, if the first m$m$ terms of y$y$ are the same as those of x$x$ (that is, if y$y$ is “close” to x$x$ in some sense), then the procedure must return the same value of n$n$ for y$y$ as it would give for x$x$. The procedure is thus a continuous function (the choice function) from NN$mathbb{N}^mathbb{N}$ to N$mathbb{N}$.\n\nThe principle of continuous choice is a restricted form of the classical axiom of choice (see Section 1f). This principle (together with the BHK interpretation) gives rise to a number of very strong consequences—perhaps the most (in)famous being that every function f:RR$f:mathbb{R} to mathbb{R}$ which maps the real line into itself is pointwise continuous.\n\nIf this seems outlandish, then remember that in intuitionistic mathematics the very ideas of “function” and “real number” are different from their classical counterparts. We now discuss a technique that originated with Brouwer which justifies, to some extent, these conceptions.\n\n### a. Brouwerian counterexamples\n\nAs we have seen, Brouwer rejected the principle of excluded middle. The intuitionist school further rejects appeal to so-called omniscience principles; logical principles which allow one to decide the truth of predicates over an infinite number of things. An illuminating example of such a principle is the limited principle of omniscience (LPO), which states that:\n\nFor each binary sequence a1a2a3$a_1a_2a_3…$, either an=0$a_n = 0$ for all natural numbers n$n$ or there exists a natural number n$n$ such that an=1$a_n = 1$.\n\nIn symbols LPO states that, for any given binary sequence a1a2a3$a_1a_2a_3…$, the following statement is decidable:\n\nn(an=0)n(an=1).\n\nFor one familiar with computability, the above statement will already appear problematical. It says that there is an algorithm which, given an arbitrary binary sequence will in finite time determine either that all the terms in α$alpha$ are zero, or it will output an n$n$ such that an=1$a_n = 1$. Since computers have a finite memory capacity, the problem of loss of significance (or underflow) occurs: the computer carrying out the calculation may not carry enough digits of the sequence to determine whether a 1$1$ occurs or not (though see Section 3).\n\nHowever, (modern) computational issues aside, this was not the problem seen by the intuitionist. To Brouwer, the possible existence of choice sequences made this statement unacceptable. Since a constructing agent is free to insert a 1$1$ while constructing a sequence at any stage of the construction, there is no a priori bound on how many terms one may need to search in order to establish the presence, or lack of, a 1$1$.\n\nThus we see that the lesser principle of omniscience does not apply to binary sequences in intuitionist mathematics. Let us now turn to the real numbers. The decimal expansion of π$pi$ is a favourite example. There are well-known algorithms for computing π$pi$ to arbitrary precision, limited only by the power of the device on which the algorithms run. At the time of writing this article, it is unkown whether a string of 100 successive 0$0$s (that is, 0000$000…0$, with 100 digits) appears in the decimal expansion of π$pi$. It is known that π$pi$ does not have a terminating decimal expansion (so it does not finish in all 0$0$s) and that it has no systematic repetition (since it is not a rational number).\n\nBut suppose we define a real number x$x$ by the expansion\n\nx=n=1(12)nan\n\nwhere an$a_n$ is defined as\n\nan={01if a hundred consecutive 0s have not occurred by the nth digit of π‘s expansionotherwise.\n\nThe number x$x$ is constructible: we have prescribed an algorithm for computing it to any desired precision. It also has a Cauchy condition—the 1/2n$1/2^n$ part—which ensures it converges. However, we now have a problem as regards the sign of x$x$: if a hundred consecutive 0$0$s never occur in the decimal expansion of π$pi$, then x=0$x = 0$. If a hundred consecutive 0$0$s do occur in the decimal expansion of π$pi$, and the hundredth such 0$0$ occurs in an odd place, then x<0$x < 0$; whereas if it occurs in an even place then x>0$x > 0$. So if we have an answer to the question whether such a string occurs in the decimal expansion of π$pi$, then we can determine whether x=0$x = 0$ or not; however, since we do not have an answer, we cannot conclude that x>0$x >0$, or x=0$x=0$, or x<0$x<0$.\n\nThe previous paragraph is a Brouwerian counterexample to the statement \"every real number satisfies the law of trichotomy\". Trichotomy is exactly the decision (disjunction) that every real number is either positive, zero, or negative. Under Brouwer's view, we may construct real numbers about which we simply do not have enough information at hand—even in principle—to determine their sign.\n\n### b. The Fan Theorem\n\nIn addition to the use of intuitionistic logic and the principle of continuous choice, Brouwer's intuitionism involves one final central technique, bar induction. It is a technically challenging idea which we do not cover in depth here (see Beeson, 1985, p. 51 or Troelstra & van Dalen, 1988, p. 229 for detail; see also Bridges, Dent & McKubre-Jordens, 2012). Bar induction is a key principle which allowed Brouwer to prove his Fan Theorem; we will outline the theorem for the binary fan, demonstrating the significance of the fan theorem.\n\nThe (complete) binary fan is the collection of all (finite) sequences of 0$0$s and 1$1$s (including the empty sequence). Diagrammatically, we may draw a tree-like diagram (the \"fan\") with a binary split for each branch at each level; one branch corresponds to 0$0$, another to 1$1$. A path through the binary fan is a sequence (finite or infinite) of 0$0$s and 1$1$s. Compare then:\n\n• A bar of the binary fan is a set of cut-offs', such that for each infinite path α$alpha$ through the fan there exists a natural number n$n$ such that the first n$n$ terms of α$alpha$ are in the bar'.\n• A bar of the binary fan is uniform if there exists a natural number N$N$ such that for each infinite path α$alpha$ through the fan, there is some kN$k leq N$ such that the first k$k$ terms of α$alpha$ are in the bar.\n\nNote the quantifier shift: we go from \"for each path there exists n$n$…\" to \"there exists N$N$ such that for each path …\". Brouwer's fan theorem for the binary fan then states that\n\nFAN: Every bar of the binary fan is uniform.\n\nThe classical contrapositive of the fan theorem, well-known in graph theory, is König's Lemma: if for every n$n$ there exists a path of length n$n$ which does not hit the bar, then there exists an infinite path that is not in the bar.\n\nAs mentioned, the fact that Brouwer's proof of the fan theorem (1927) was published nine years before König's proof of his Lemma (1936) shows the innaccuracy of the criticism sometimes held that constructive mathematics is revisionist. Indeed, as is shown by the Gödel-Gentzen negative translation (Gödel, 1933), every classical theorem may be translated into a constructive theorem (some of which are not very informative); and so constructive mathematics can be interpreted as a generalization of classical mathematics. If one adds PEM to intuitionistic logic, then the full classical system is recovered. (Of course, the reverse view may also be argued for—that classical mathematics is a generalization of constructive methods.)\n\n## 3. Constructive recursive mathematics\n\nIn the 1930s, amidst developments in what is now known as computer science, concepts of algorithmic computability were formalised. The well-known Turing machines, λ$lambda$-calculus, combinatory logic and the like arose. These were proved to be equivalent, leading Church, Turing and Markov to postulate the thesis now known as the Church-Markov-Turing thesis (or the Church-Turing thesis, or simply Church's thesis):\n\nCMT: a function is computable if and only if it is computable by a Turing machine.\n\nMarkov's work, based in what he called normal algorithms (now known as Markov algorithms; Markov, 1954) was essentially recursive function theory employing intuitionistic logic. In this type of constructive mathematics, the groundwork for which was done in the 40s and 50s, Church's thesis is accepted as true (as it is to classical mathematicians, by and large). Moreover, in Markov's school, Markov's Principle of unbounded search is accepted:\n\nMP: For any binary sequence, if it is impossible that all the terms are zero, then there exists a term equal to 1.\n\nThis reflects the idea that if it is contradictory for all the terms to be zero, then (although we do not have an a priori bound on how far in the sequence we must seek) eventually any machine that is looking for a 1$1$ will find one in finite (possibly large) time.\n\nWhile MP may seem like a kind of omniscience principle, there is a distinct difference: the implication PQ$P to Q$ is, under the BHK interpretation, weaker than the disjunction ¬PQ$neg P lor Q$. An algorithm which takes any (correct) proofs of P$P$ and turns them into (correct) proofs of Q$Q$ does not leave us any the wiser which of ¬P$neg P$ or Q$Q$ is actually the case. In part because of this, the constructive status of this principle is not so clear. While the omniscience principles are not accepted by any school of constructivism, there is at least pragmatic (that is, computer-implementable) reason to admit MP: the algorithm which will compute the 1$1$ in a binary sequence for which it is impossible that all terms are 0$0$ is simply to carry on the process of writing the sequence down until you come across a 1$1$. Of course, MP does not provide a guarantee that a 1$1$ will be found in a sequence before, say, the extinction of the human race, or the heat death of the universe.\n\nRecursive function theory with intuitionistic logic and Markov's principle is known as Russian recursive mathematics. If Markov's principle is omitted, this leaves constructive recursive mathematics more generally—however, there appear to be few current practitioners of this style of mathematics (Beeson, 1985, p. 48).\n\nA central tenet of recursive function theory, is the following axiom of Computable Partial Functions:\n\nCPF: There is an enumeration of the set of all computable partial functions from N$mathbb{N}$ to N$mathbb{N}$ with countable domains.\n\nMuch may be deduced using this seemingly innocuous axiom. For example, PEM (and weakenings thereof, such as LPO) may be shown to be (perhaps surprisingly) simply false within the theory.\n\n### a. Surprises\n\nConstructive recursive mathematics presents other surprises as well. Constructivists are already skeptical about PEM, LPO, and other wide-reaching principles. However, some amazing (and classically contradictory) results can be obtained, such as Specker's theorem (Specker, 1949):\n\nTheorem.\nThere exists a strictly increasing sequence (xn)n1$left(x_nright)_{n geq 1}$ of rational numbers in the closed interval [0,1]$[0,1]$ that is eventually bounded away from each real number in [0,1]$[0,1]$.\n\nTo be `eventually bounded away from a number x$x$' means that, given the number x$x$, one may calculate a positive integer N$N$ and a positive distance δ$delta$ such that the distance from x$x$ to xk$x_k$ is at least δ$delta$ whenever kN$k geq N$.\n\nOf course such sequences cannot be uniformly bounded away from the whole of [0,1]$[0,1]$, otherwise they could not progress within [0,1]$[0,1]$ past this uniform bound (again, there is a quantifier swap, from the pointwise property xN,δ$forall_x exists_{N,delta}$ to the uniform property N,δx$exists_{N,delta} forall_x$—recall Section 2b). While it seems like a contradictory result, the theorem becomes clear when one considers the objects of study: sequences (and functions) and real numbers, are recursive sequences and real numbers; so Specker sequences are sequences which classically converge to non-recursive numbers.\n\nAnother interesting result is the constructive existence, within this theory, of a recursive function from [0,1]$[0,1]$ to the reals which is everywhere pointwise continuous yet not uniformly continuous (as such a function would be both classically and intuitionistically, as a consequence of Brouwer's fan theorem).\n\n## 4. Bishop's constructive mathematics\n\nIn 1967 Errett Bishop published the seminal monograph Foundations of Constructive Analysis (Bishop, 1967). Not only did this assuage the worries expressed by some leading mathematicians (such as Weyl) about the feasibility of constructive proofs in analysis, but it helped lay the foundation for a programme of mathematical research that has flourished since. It captures the numerical content of a large part of the classical research programme and has become the standard for constructive mathematics in the broader sense, as we will shortly see.\n\n### a. Proof readability and preservation of numerical meaning\n\nBishop refused to formally define the notion of algorithm in the BHK interpretation. It is in part this quality which lends Bishop-style constructive mathematics (BISH) the following property: every other model of constructive mathematics, philosophical background notwithstanding, can be seen as an interpretation of Bishop's constructive mathematics where some further assumptions have been added. For example, intuitionistic mathematics is BISH together with bar induction and continuous choice; and (Russian) constructive recursive mathematics is BISH together with the Computable Partial Functions axiom and Markov's Principle. Even classical mathematics—or mathematics with classical two-valued logic—can be seen as a model of Bishop-style constructive mathematics where the principle of excluded middle is added as axiom.\n\nAnother factor that contributes to this versatility is the fact that Bishop did not add extra philosophical commitments to the programme of his constructive mathematics, beyond the commitment of ensuring that every theorem has numerical meaning (Bishop, 1975). The idea of preserving numerical meaning is intuitive: the numerical content of any fact given in the conclusion of a theorem must somehow be algorithmically linked to (or preserved from) the numerical content of the hypotheses. Thus BISH may be used to study the same objects as the classical mathematician (or the recursive function theorist, or the intuitionist). As a result, a proof in Bishop-style mathematics can be read, understood, and accepted as correct, by everyone (Beeson, 1985, p. 49) (barring perhaps the paraconsistentists, for whom the disjunctive syllogism, weakening, and contraction—accepted under BHK—portend trouble).\n\nAt heart, Bishop's constructive mathematics is simply mathematics done with intuitionistic logic, and may be regarded as \"constructive mathematics for the working mathematician\" (Troelstra & van Dalen, 1988, p. 28). If one reads a Bishop-style proof, the classical analyst will recognize it as mathematics, even if some of the moves made within the proof seem slightly strange to those unaccustomed to preserving numerical meaning. Further, BISH can be interpreted in theories of computable mathematics, such as Weihrauch's Type 2 effectivity theory (Weihrauch, 2000).\n\n### b. The Axiom of Choice in BISH\n\nOne (in)famous claim Bishop makes is that \"A choice function exists in constructive mathematics, because a choice is implied by the very meaning of existence\" (Bishop & Bridges, 1985, p. 12). The axiom is in fact provable in some constructive theories (see Section 5). However, Diaconescu has shown that AC implies PEM, so it would seem that constructivists ought to accept PEM after all (the proof in Diaconescu (1975) is actually remarkably simple). And as we have seen, for some constructivists it would actually be inconsistent to accept PEM. It thus seems that AC, while very important, presents a significant problem for constructivists. However, as we now discuss, such a conclusion is hasty and unjustified.\n\nThe key observation to make regards the interpretation of the quantifiers. AC comes out as provable only when we interpret the quantifiers under BHK: for then the hypothesis xAyBP(x,y)$forall_{x in A} exists_{y in B} P(x,y)$ says that there is an algorithm which takes us from elements x$x$ of A$A$ together with the data that x$x$ belongs to A$A$, to an element y$y$ of B$B$. Thus only if there is no extra work to be done beyond the construction of x$x$ in showing that x$x$ is a member of A$A$ (that is, if this can be done uniformly) will this be a genuine function from A$A$ to B$B$. We will revisit this in Section 5. Thus the classical interperatation of AC is not valid under BHK, and PEM cannot be problematically derived.\n\nLet us return to Bishop's statement at the start of this section, regarding the existence of a choice function being implied by the meaning of existence. The context in which his claim was made illuminates the situation. The passage (Bishop & Bridges, 1985, p. 12) goes on to read: \"[Typical] applications of the axiom of choice in classical mathematics either are irrelevant or are combined with a sweeping use of the principle of omniscience.\" This also shows that blaming the axiom of choice for non-constructivity is actually a mistake—it is the appeal to PEM, LPO, or similar absolute principles applied to objects other than the finite which prevent proof from being thoroughly algorithmic. Some constructive mathematicians adopt various weakenings of AC which are (perhaps) less contentious; Brouwer, as we saw in Section 2, adopts Continuous Choice.\n\nBishop's view is that the Gödel interpretation of logical symbols accurately describes numerical meaning (Bishop, 1970). This view does not appear to have retained much traction with practitioners of BISH (Beeson, 1985, p. 49). Leaving the question of foundations open is, as mentioned, partly responsible for the portability of Bishop-style proofs.\n\nSome work has been done on founding BISH. A set-theoretic approach was proposed in Myhill (1975) and Friedman (1977); Feferman (1979) suggested an approach based on classes and operations. Yet another approach is Martin-Löf's theory of types, which we visit in Section 5.\n\nThe Techniques of Constructive Analysis book (Bridges & Vîta, 2006) develops a Bishop-style constructive mathematics that revisits and extends the work from Bishop (1967) in a more modern setting, showing how modern proof techniques from advanced topics such as Hilbert spaces and operator theory can be successfully covered constructively. It is interesting to observe that, as a rule of thumb, the more ingenious a proof looks, the less explicit numerical content it tends to contain. Thus such proofs are usually more difficult to translate into constructive proofs. Of course there are exceptions, but the comparison between (say) Robinson's nonstandard analysis and Bishop's constructive methods appears to be a confusion between elegance and content propagated by some authors; see, for example, Stewart (1986) and Richman (1987).\n\n## 5. Martin-Löf Type Theory\n\nIn 1968, Per Martin-Löf published his Notes on Constructive Mathematics (Martin-Löf, 1968). It encapsulates mathematics based on recursive function theory, with a background of the algorithms of Post (1936).\n\nHowever he soon revisited foundations in a different way, which harks back to Russell's type theory, albeit using a more constructive and less logicist approach. The basic idea of Martin-Löf's theory of types (Martin-Löf, 1975) is that mathematical objects all come as types, and are always given in terms of a type (for example, one such type is that of functions from natural numbers to natural numbers), due to an intuitive understanding that we have of the notion of the given type.\n\nThe central distinction Martin-Löf makes is that between proof and derivation. Derivations convince us of the truth of a statement, whereas a proof contains the data necessary for computational (that is, mechanical) verification of a proposition. Thus what one finds in standard mathematical textbooks are derivations; a proof is a kind of realizability (c.f. Kleene, 1945) and links mathematics to implementation (at least implicitly).\n\nThe theory is very reminiscent of a kind of cumulative hierarchy. Propositions can be represented as types (a proposition's type is the type of its proofs), and to each type one may associate a proposition (that the associated type is not empty). One then builds further types by construction on already existing types.\n\n### a. The Axiom of Choice is provable\n\nWithin Martin-Löf type theory, the axiom of choice, stated symbolically as\n\nxAyBP(x,y)fBAxAP(x,f(x))\n\nis derivable. Recall that this would be inconsistent, if AC were interpreted classically. However the axiom is derivable because in the construction of types, the construction of an element of a set (type) is sufficient to prove its membership. In Bishop-style constructive mathematics, these sets are \"completely presented\", in that we need to know no more than an object's construction to determine its set membership. Under the BHK interpretation, the added requirement on the proof of xAP(x)$forall_{x in A} P(x)$ that the algorithm may depend also on the data that x$x$ belongs to A$A$ and not just on the construction of x$x$ itself is thus automatically satisfied.\n\nIt is worth noting that sets construed in this theory are constrained by this realizability criterion. For example, in Martin-Löf's theory, the power set axiom is not accepted in full generality—the power set of N$mathbb{N}$, for example, is considered to be what would in classical theory be called a class, but not a set (Martin-Löf, 1975).\n\n## 6. Constructive Reverse Mathematics\n\nThe program of Reverse Mathematics, instigated by Harvey Friedman (1975), aims to classify theorems according to their equivalence to various set-theoretic principles. The constructive equivalent was begun in a systematic manner by Ishihara (2006) and, separately and independently by W. Veldman in 2005.\n\nThe field has since had numerous developments, the interest of which lies mainly in the metamathematical comparison of different branches of constructive mathematics and the logical strengths of various principles endorsed or rejected by the different schools. This also points to the requirements on computational data for various properties to hold, such as various notions of compactness (Diener, 2008).\n\nPrinciples whose classification is of interest include:\n\n• The Uniform Continuity Theorem (UCT): Every pointwise continuous mapping of the closed interval [0,1]$[0,1]$ into R$mathbb{R}$ is uniformly continuous.\n• Brouwer's fan theorem, and various weakenings thereof. (There is actually a hierarchy of fan theorems; see, for example, Diener, 2008.)\n• The Anti-Specker property (AS): A sequence (zn)n1$(z_n)_{ngeq 1}$ of real numbers in [0,1]$[0,1]$ that is eventually bounded away from each point of [0,1]$[0,1]$ is eventually bounded away from all of [0,1]$[0,1]$ (recall the discussion in Section 3a).\n• Omniscience principles.\n\nIt should be noted that arguably the first author dealing with reverse-mathematical ideas was Brouwer, although he certainly would not have seen it as such. The weak counterexamples (see Section 2a) he introduced were of the form: P$P$ implies some non-constructive principle. Though Brouwer may have been aware of the possibility of reversing the implication in many cases, to him non-constructive principles were meaningless and as such the full equivalence result would be of little interest.\n\n## 7. Summary\n\nThe philosophical commitments of constructivist philosophies (Section 1b) are:\n\n• Truth is replaced by (algorithmic) proof as a primitive notion, and\n• Existence means constructibility.\n\nThis naturally leads to intuitionistic logic, characterized by the BHK interpretation (Section 1c). Omniscience principles, such as the Principle of Excluded Middle (PEM), and any mode of argument which validates such principles, are not in general valid under this interpretation, and the classical equivalence between the logical connectives does not hold.\n\nConstructive proofs of classical theorems are often enlightening: the computational content of the hypotheses is explicitly seen to produce the conclusion. While intuitionistic logic places restrictions on inferences, the larger part of classical mathematics (or what is classically equivalent) can be recovered using only constructive methods (Section 4); there are often several constructively different versions of the same classical theorem.\n\nThe computational advantage of constructive proof is borne out in two ways. Constructive proofs:\n\n• embody (in principle) an algorithm (for computing objects, converting other algorithms, etc.), and\n• prove that the algorithm they embody is correct (that is, that it meets its design specification).\n\nThe programme of constructive reverse mathematics (Section 6) connects various principles and theorems (such as omniscience principles, versions of the fan theorem, etc.), shedding light on constructive or computational requirements of theorems. Furthermore, the use of Brouwerian counterexamples (Section 2a) often allows the mathematician to distinguish which aspects of classical proof are essentially nonconstructive.\n\nThrought the article, several schools of constructivism are outlined. Each is essentially mathematics with intuitionistic logic, philosophical differences notwithstanding. Different schools add different further axioms: for example, (Russian) constructive recursive mathematics (Section 3) is mathematics with intuitionistic logic, the computable partial functions axiom (and Markov's principle of unbounded search). Classical mathematics can be interpreted as Bishop's constructive mathematics, with PEM added.\n\n### a. Some Further Remarks\n\nThe contrast between classical and constructive mathematicians is clear: in order to obtain the numerical content of a proof, the classical mathematician must be careful at each step of the proof to avoid decisions that cannot be algorithmically made; whereas the constructive mathematician, in adopting intuitionistic logic, has automatically dealt with the computational content carefully enough that an algorithm may be extracted from their proof.\n\nIn an age where computers are ubiquitous, the constructivist programme needs even less (pragmatic) justification, perhaps, than the classical approach. This is borne out by the successful translation of constructive proofs into actual algorithms (see, for example, Schwichtenberg (2009) and Berger, Berghofer, Letouzey & Schwichtenberg (2006)). The link between programming and abstract mathematics is stronger than ever, and will only strengthen as new research emerges.\n\n## 8. References and Further reading\n\nAn overview of constructivism in mathematics is given in both Troelstra & van Dalen (1988), and Beeson (1985). For further reading in intuitionism from a philosophical perspective, Dummett's Elements (1977) is the prime resource. The Bishop and Bridges book (1985) is the cornerstone textbook for the Bishop-style constructivist. For the finitist version, see Ye (2011), where it is shown that even a strict finitist interpretation allows large tracts of constructive mathematics to be realized; in particular we see application to finite things of Lebesgue integration, and extension of the constructive theory to semi-Riemannian geometry. For advances and techniques in Bishop-style mathematics, see Bridges & Vîta (2006). For an introduction to constructive recursive function theory, see Richman (1983); Bridges & Richman (1987) expounds the theory relative to other kinds of constructive mathematics. For an introduction to computable analysis, see, for example, Weihrauch (2000). For topology, Bridges & Vîta (2011) outlays a Bishop-style development of topology; Sambin (1987) and (2003) are good starting points for further reading in the recent development of point-free (or formal) topology.\n\n### b. References\n\n• Beeson, M. (1985). Foundations of constructive mathematics. Heidelberg: Springer-Verlag.\n• Berger, U., Berghofer, S., Letouzey, P. & Schwichtenberg, H. (2006). Program extraction from normalization proofs. Studia Logica, 82, 25–49.\n• Bishop, E. (1967). Foundations of constructive analysis. New York: Academic Press.\n• Bishop, E. (1970). Mathematics as a numerical language. In A. Kino, J. Myhill & R. E. Vesley (Eds.), Intuitionism and proof theory: proceedings of the summer conference at Buffalo, New York, 1968 (pp. 53–71). Amsterdam: North-Holland.\n• Bishop, E. (1973). Schizophrenia in contemporary mathematics. Amer. Math. Soc. Colloquium Lectures. Missoula: University of Montana. Reprinted in: Rosenblatt, M. (1985). Errett bishop: reflections on him and his research. (M. Rosenblatt. & E. Bishop, Eds.) Amer. Math. Soc. Memoirs 39.\n• Bishop, E. (1975). The crisis in contemporary mathematics. Historia Mathematica, 2(4), 507–517.\n• Bishop, E. & Bridges, D. S. (1985). Constructive analysis. Berlin: Springer-Verlag.\n• Borel, E. (1914). Leçons sur la théorie des fonctions (2nd ed.). In French. Paris: Gauthier-Villars.\n• Bradley, R. E. & Sandifer, C. E. (2009). Cauchy's cours d'analyse. New York: Springer.\n• Bridges, D. & Richman, F. (1987). Varieties of constructive mathematics. London Math. Soc. Lecture Notes 97. Cambridge: Cambridge University Press.\n• Bridges, D. S. & Vîta, L. S. (2006). Techniques of constructive analysis. Universitext. Heidelberg: Springer-Verlag.\n• Bridges, D. S. & Vîta, L. S. (2011). Apartness and uniformity: a constructive development. Heidelberg: Springer.\n• Bridges, D. S., Dent, J. & McKubre-Jordens, M. (2012). Two direct proofs that LLPO implies the detachable Fan Theorem. Preprint.\n• Brouwer, L. E. J. (1907). Over de grondslagen der wiskunde. (Doctoral dissertation, University of Amsterdam, Amsterdam). In Dutch.\n• Brouwer, L. E. J. (1908). De onbetrouwbaarheid der logische principes. Tijdschrift voor Wijsbegeerte, 2, 152–158. In Dutch.\n• Brouwer, L. E. J. (1912). Intuïtionisme en formalisme. Wiskundig Tijdschrift, 9, 180–211. In Dutch.\n• Brouwer, L. E. J. (1914). Review of Schoenflies's \"Die Entwicklung der Mengenlehre und ihre Anwendungen, erste Hälfte\". Jahresber. Dtsch. Math.-Ver. 23(2), 78–83.\n• Brouwer, L. E. J. (1927). On the domains of definition of functions. Reprinted in: van Heijenoort, J. (1976). From Frege to Gödel: a source book in mathematical logic, 1879–1931 (2nd printing with corrections). Cambridge, Massachusetts: Harvard University Press.\n• Cauchy, A.-L. (1821). Cours d'analyse. English translation: Bradley, R. E. & Sandifer, C. E. (2009). Cauchy's cours d'analyse. New York: Springer\n• Diaconescu, R. (1975). Axiom of choice and complementation. Proc. Amer. Math. Soc. 51, 176–178.\n• Diener, H. (2008). Compactness under constructive scrutiny. (Doctoral dissertation, University of Canterbury, New Zealand).\n• Dummett, M. A. E. (1977). Elements of intuitionism. Oxford: Clarendon Press.\n• Feferman, S. (1979). Constructive theories of functions and classes. In Logic colloquium '78 (Proc. Mons Colloq.) (pp. 159–224). Stud. Logic Foundations Math. 97. Amsterdam: North-Holland.\n• Friedman, H. (1975). Some systems of second order arithmetic and their use. In Proceedings of the 17th international congress of mathematicians (Vancouver, British Columbia, 1974).\n• Friedman, H. (1977). Set theoretic foundations for constructive analysis. Ann. Math. 105(1), 1–28.\n• Gödel, K. (1933). Zur intuitionistischen arithmetik und zahlentheorie. Ergebnisse eines mathematischen Kolloquiums, 4, 34–38. In German.\n• Hilbert, D. (1890). Über die theorie der algebraischen formen. Math. Ann. 36, 473–534. In German.\n• Ishihara, H. (2006). Reverse mathematics in bishop's constructive mathematics. Phil. Scientiae. Cahier Special 6, 43–59.\n• Kleene, S. C. (1945). On the interpretation of intuitionistic number theory. J. Symbolic Logic, 10(4), 109–124.\n• König, D. (1936). Theorie der endlichen und unendlichen graphen: kombinatorische topologie der streckenkomplexe. In German. Leipzig: Akad. Verlag.\n• Kronecker, L. (1887). Über den zahlbegriff. J. Reine Angew. Math. 101, 337–355. In German.\n• Markov, A. A. (1954). Theory of algorithms, In Trudy Mat. Istituta imeni V. A. Steklova (Vol. 42). In Russian. Moskva: Izdatel'stvo Akademii Nauk SSSR.\n• Martin-Löf, P. (1968). Notes on constructive analysis. Stockholm: Almqvist & Wiksell.\n• Martin-Löf, P. (1975). An intuitionistic theory of types: predicative part. In H. E. Rose & J. C. Shepherdson (Eds.), Logic colloquium 1973 (pp. 73–118). Amsterdam: North-Holland.\n• Myhill, J. (1975). Constructive set theory. J. Symbolic Logic, 40(3), 347–382.\n• Poincaré, H. (1908). Science et méthode. In French. Paris: Flammarion.\n• Post, E. (1936). Finite combinatory processes - formulation 1. J. Symbolic Logic, 1, 103–105.\n• Richman, F. (1983). Church's thesis without tears. J. Symbolic Logic, 48, 797–803.\n• Richman, F. (1987). The frog replies. The Mathematical Intelligencer, 9(3), 22–24. See also the subsequent discussion, pp. 24–26.\n• Rosenblatt, M. (1985). Errett bishop: reflections on him and his research (M. Rosenblatt & E. Bishop, Eds.). Amer. Math. Soc. Memoirs 39.\n• Sambin, G. (1987). Intuitionistic formal spaces - a first communication. In D. Skordev (Ed.), Mathematical logic and its applications (pp. 187–204). New York: Plenum.\n• Sambin, G. (2003). Some points in formal topology. Theoretical Computer Science, 305, 347–408.\n• Schwichtenberg, H. (2009). Program extraction in constructive analysis. In S. Lindström, E. Palmgren & K. Segerberg (Eds.), Logicism, intuitionism, and formalism: what has become of them? (pp. 255–275). Heidelberg: Springer.\n• Specker, E. (1949). Nicht konstruktiv beweisbare sätze der analysis. J. Symbolic Logic, 14, 145–158. In German.\n• Stewart, I. (1986). Frog and mouse revisited: a review of Constructive Analysis by Errett Bishop and Douglas Bridges (Springer 1985) and An Introduction to Nonstandard Real Analysis by A. E. Hurd and P. A. Loeb. The Mathematical Intelligencer, 8(4), 78–82.\n• Troelstra, A. S. & van Dalen, D. (1988). Constructivism in mathematics: an introduction. Two volumes. Amsterdam: North Holland.\n• van Heijenoort, J. (1976). From Frege to Gödel: a source book in mathematical logic, 1879–1931 (2nd printing with corrections). Cambridge, Massachusetts: Harvard University Press.\n• Weber, H. (1893). Leopold Kronecker. Math. Ann., 43, 1–25.\n• Weihrauch, K. (2000). Computable analysis. EATCS Texts in Theoretical Computer Science. Heidelberg: Springer-Verlag.\n• Weyl, H. (1946). Mathematics and logic. Amer. Math. Monthly, 53, 2–13.\n• Ye, F. (2011). Strict Finitism and the logic of mathematical applications. Synthese Library 355. Heidelberg: Springer.\n• Zermelo, E. (1904). Beweis, dass jede menge wohlgerdnet werden kann. Math. Ann., 59, 514–516. In German.\n\n### Author Information\n\nMaarten McKubre-Jordens\nEmail: [email protected]\nUniversity of Canterbury\nNew Zealand" ]

[ null, "https://iep.utm.edu/wp-content/ql-cache/quicklatex.com-022ac3559472aad999b3897d4547b17b_l3.png", null, "https://iep.utm.edu/wp-content/ql-cache/quicklatex.com-cc6dbec9db746208dd465f4b6a2f220a_l3.png", null ]

[ "# How can I plot two parametric functions in a common coordinate system?\n\nI can easily use parametric_plot() to plot 1 parametric function at once. For example\n\nparametric_plot((sin(2*t),cos(3*t)),(t,0.0,9),aspect_ratio=1)\n\n\nplots a nice Lissajous curve.\n\nI also can plot a circle:\n\nparametric_plot((sin(t),cos(t)),(t,0.0,9),aspect_ratio=1)\n\n\nBut how can I plot both of them in a common coordinate system?\n\nI tried:\n\nparametric_plot([(sin(2*t),cos(3*t)),(sin(t),cos(t))],(t,0.0,9),aspect_ratio=1)\n\n\nWhich doesn't work -> Last error message: ''tuple' object is not callable'\n\nI also tried:\n\npl1=parametric_plot((sin(t),cos(t)),(t,0.0,9),aspect_ratio=1)\npl2=parametric_plot((sin(2*t),cos(3*t)),(t,0.0,9),aspect_ratio=1)\npl1\n\n\nError: 'Graphics' object has no attribute 'options'\n\nThen how can I use parametric_plot() to plot two parametric functions at once, in a common coordinate system?\n\nedit retag close merge delete\n\nSort by » oldest newest most voted\n\nGraphics object can be combined using +.\n\nSo in your case this should work:\n\nsage: pl = pl1 + pl2\nsage: pl\n\n\nEdit, inspired by @Emmanuel Charpentier's comment to my initial answer.\n\nThis works too:\n\nsage: t = SR.var('t')\nsage: xys = [[sin(2*t), cos(3*t)], [sin(t), cos(t)]]\nsage: sum(parametric_plot(xy, (t, 0.0, 9.0), aspect_ratio=1) for xy in xys)\n\nmore\n\nAlternates to slelievre's solution :\n\nsage: t=SR.var(\"t\")\nsage: L=[[sin(2*t),cos(3*t)],[sin(t),cos(t)]]\nsage: sum(map(lambda c:parametric_plot(c,(t,0.0,9),aspect_ratio=1), L))\nLaunched png viewer for Graphics object consisting of 2 graphics primitives\nsage: sum(map(lambda c:plot(c,(t,0.0,9),aspect_ratio=1,parametric=True), L))\nLaunched png viewer for Graphics object consisting of 2 graphics primitives\n\n\nHTH," ]

[ null ]

[ "# SI prefixes\n\nThe 20 SI prefixes are pre-symbols, used to form decimal multiples and submultiples of SI units. For example kilometre (km), kilo means a thousand times. Another example is millimetre (mm), where milli means thousandth part of something.\n\nContents: SI prefix calculator and SI prefix table.\n\n## SI prefix conversion calculator:\n\nEnter the number in green field and click at \"=\" button:\n\n?\n\n(result)\n\n## SI prefix table\n\nSI prefix tables contains 10+10 SI prefixes. First table contains multiple prefixes (they are bigger than base unit) and submultiple prefixes (smaller than base unit). You can find examples below tables:\n\n### Multiple prefixes:\n\nName  Symbol Factor\nyotta Y 1024\nzetta Z 1021\nexa E 1018\npeta P 1015\ntera T 1012\ngiga G 109\nmega M 106\nkilo k 103\nhecto h 102\ndeka da 101\n(base) - 100=1\n\nExamples:\n\n• 1 hm = 1×102 m = 100 m\n• 2 kN = 2×103 N = 2000 N\n• 5 MHz = 5×106 Hz = 5 000 000 Hz\n\n### Submultiple prefixes:\n\nName  Symbol Factor\n(base) - 100=1\ndeci d 10-1\ncenti c 10-2\nmilli m 10-3\nmicro µ 10-6\nnano n 10-9\npico p 10-12\nfemto f 10-15\natto a 10-18\nzepto z 10-21\nyocto y 10-24\n\nExamples:\n\n• 1 cm = 1×10-2 m = 0.01 m\n• 2 ms = 2×10-3 s = 0.002 s\n• 5 µm = 5×10-6 m = 0.000001 m\n\nNotice:\n\n• Multiple prefixes may not be used, in the case of the kilogram (SI base unit for mass) symbol already have prefix. Example: 10-6 kg = 1 mg and not 1 µkg (µ and k prefixes can not be used together in one unit)\n• Usage of prefixes which are not dividable with 103 (in tables with RED letters) is recommended only with few units (examples: hectoliter hL, hectopascal hPa, dekagram dg, centimetre cm..)\n• SI prefixes strictly represent powers of 10, they should not be used to represent powers of 2. Example, 1 kByte, is 1000 Byte and not 210 Byte = 1024 Byte. See also: binary prefixes..\n\nSource: NIST.gov - prefixes. (retrieved 2017-04-18)", null, "" ]

[ null, "http://conversion.org/menufiles/top.png", null ]

[ "|\n\n# 墙面翻新上漆步骤,具体的步骤是什么\n\n1、清洁旧墙：一般来说，旧墙会有油，灰，洞或裂缝，水的吸收率很低。然后，你必须在墙上做一些清洁工作。对于旧墙，必须首先移除浮灰，并且必须去除打磨和紧固。对于油性部件，必须首先移除原始层，并且必须彻底清洁清洁。清洁墙壁后，用腻子刮去两个。路\n\n2、刮腻子：最好使用高细度和质地坚硬的腻子。您还可以在腻子中添加一定的白色乳胶，以提高腻子的硬度。\n\n3、打磨：尽量使用细砂纸，一般较软的腻子(如821)用400-500砂纸，较硬的质地(如墙衬，易呱平)与360-400更好，如果砂纸如果太厚，会留下深刻的沙痕，油漆将无法覆盖。抛光后，应彻底清洁墙壁，避免灰尘过多，影响油漆的附着力。高度差不大于3毫米。", null, "4、上底漆：底漆应均匀刷涂，以确保墙壁的每个部分都经过刷涂。如果墙壁涂有大量涂料，请在底漆中加入少许水，以确保涂层均匀。不要以为它是带有小底漆的滚筒，因为它是底漆。底漆的效果将直接影响顶层的效果。使用与顶层相同的纹理辊。\n\n5、墙面翻新上漆步骤-找补：一旦腻子完成，就会有一些洞，在正常情况下很难看到。只有在刷完油漆后才会明显。此时，你应该寻找，注意应该平滑的修复，然后用更多的水基底刷，以避免由于其他墙壁的水摄入量差异造成的色差。\n\n6、墙面翻新上漆步骤-最后一层刷漆：不要在油漆中加入过量的水。它会影响漆膜的厚度，漆膜的手感和硬度。尝试选择更好的工具。滚筒不应太短，但应该很薄。手的细腻，要特别注意墙角，每个卷的间接部分和绘画的方向。\n\n7、墙面翻新上漆步骤-保养：乳胶漆在4小时后会干燥，但干漆膜未达到一定的硬度。这需要小心。这很简单不要摩擦或触摸墙壁7至10天。\n\n`声明：本文由入驻焦点开放平台的作者撰写，除焦点官方账号外，观点仅代表作者本人，不代表焦点立场错误信息举报电话： 400-099-0099，邮箱：[email protected]，或点此进行意见反馈，或点此进行举报投诉。`", null, "A B C D E F G H J K L M N P Q R S T W X Y Z\nA - B - C - D - E\n• A\n• 鞍山\n• 安庆\n• 安阳\n• 安顺\n• 安康\n• 澳门\n• B\n• 北京\n• 保定\n• 包头\n• 巴彦淖尔\n• 本溪\n• 蚌埠\n• 亳州\n• 滨州\n• 北海\n• 百色\n• 巴中\n• 毕节\n• 保山\n• 宝鸡\n• 白银\n• 巴州\n• C\n• 承德\n• 沧州\n• 长治\n• 赤峰\n• 朝阳\n• 长春\n• 常州\n• 滁州\n• 池州\n• 长沙\n• 常德\n• 郴州\n• 潮州\n• 崇左\n• 重庆\n• 成都\n• 楚雄\n• 昌都\n• 慈溪\n• 常熟\n• D\n• 大同\n• 大连\n• 丹东\n• 大庆\n• 东营\n• 德州\n• 东莞\n• 德阳\n• 达州\n• 大理\n• 德宏\n• 定西\n• 儋州\n• 东平\n• E\n• 鄂尔多斯\n• 鄂州\n• 恩施\nF - G - H - I - J\n• F\n• 抚顺\n• 阜新\n• 阜阳\n• 福州\n• 抚州\n• 佛山\n• 防城港\n• G\n• 赣州\n• 广州\n• 桂林\n• 贵港\n• 广元\n• 广安\n• 贵阳\n• 固原\n• H\n• 邯郸\n• 衡水\n• 呼和浩特\n• 呼伦贝尔\n• 葫芦岛\n• 哈尔滨\n• 黑河\n• 淮安\n• 杭州\n• 湖州\n• 合肥\n• 淮南\n• 淮北\n• 黄山\n• 菏泽\n• 鹤壁\n• 黄石\n• 黄冈\n• 衡阳\n• 怀化\n• 惠州\n• 河源\n• 贺州\n• 河池\n• 海口\n• 红河\n• 汉中\n• 海东\n• 怀来\n• I\n• J\n• 晋中\n• 锦州\n• 吉林\n• 鸡西\n• 佳木斯\n• 嘉兴\n• 金华\n• 景德镇\n• 九江\n• 吉安\n• 济南\n• 济宁\n• 焦作\n• 荆门\n• 荆州\n• 江门\n• 揭阳\n• 金昌\n• 酒泉\n• 嘉峪关\nK - L - M - N - P\n• K\n• 开封\n• 昆明\n• 昆山\n• L\n• 廊坊\n• 临汾\n• 辽阳\n• 连云港\n• 丽水\n• 六安\n• 龙岩\n• 莱芜\n• 临沂\n• 聊城\n• 洛阳\n• 漯河\n• 娄底\n• 柳州\n• 来宾\n• 泸州\n• 乐山\n• 六盘水\n• 丽江\n• 临沧\n• 拉萨\n• 林芝\n• 兰州\n• 陇南\n• M\n• 牡丹江\n• 马鞍山\n• 茂名\n• 梅州\n• 绵阳\n• 眉山\n• N\n• 南京\n• 南通\n• 宁波\n• 南平\n• 宁德\n• 南昌\n• 南阳\n• 南宁\n• 内江\n• 南充\n• P\n• 盘锦\n• 莆田\n• 平顶山\n• 濮阳\n• 攀枝花\n• 普洱\n• 平凉\nQ - R - S - T - W\n• Q\n• 秦皇岛\n• 齐齐哈尔\n• 衢州\n• 泉州\n• 青岛\n• 清远\n• 钦州\n• 黔南\n• 曲靖\n• 庆阳\n• R\n• 日照\n• 日喀则\n• S\n• 石家庄\n• 沈阳\n• 双鸭山\n• 绥化\n• 上海\n• 苏州\n• 宿迁\n• 绍兴\n• 宿州\n• 三明\n• 上饶\n• 三门峡\n• 商丘\n• 十堰\n• 随州\n• 邵阳\n• 韶关\n• 深圳\n• 汕头\n• 汕尾\n• 三亚\n• 三沙\n• 遂宁\n• 山南\n• 商洛\n• 石嘴山\n• T\n• 天津\n• 唐山\n• 太原\n• 通辽\n• 铁岭\n• 泰州\n• 台州\n• 铜陵\n• 泰安\n• 铜仁\n• 铜川\n• 天水\n• 天门\n• W\n• 乌海\n• 乌兰察布\n• 无锡\n• 温州\n• 芜湖\n• 潍坊\n• 威海\n• 武汉\n• 梧州\n• 渭南\n• 武威\n• 吴忠\n• 乌鲁木齐\nX - Y - Z\n• X\n• 邢台\n• 徐州\n• 宣城\n• 厦门\n• 新乡\n• 许昌\n• 信阳\n• 襄阳\n• 孝感\n• 咸宁\n• 湘潭\n• 湘西\n• 西双版纳\n• 西安\n• 咸阳\n• 西宁\n• 仙桃\n• 西昌\n• Y\n• 运城\n• 营口\n• 盐城\n• 扬州\n• 鹰潭\n• 宜春\n• 烟台\n• 宜昌\n• 岳阳\n• 益阳\n• 永州\n• 阳江\n• 云浮\n• 玉林\n• 宜宾\n• 雅安\n• 玉溪\n• 延安\n• 榆林\n• 银川\n• Z\n• 张家口\n• 镇江\n• 舟山\n• 漳州\n• 淄博\n• 枣庄\n• 郑州\n• 周口\n• 驻马店\n• 株洲\n• 张家界\n• 珠海\n• 湛江\n• 肇庆\n• 中山\n• 自贡\n• 资阳\n• 遵义\n• 昭通\n• 张掖\n• 中卫\n\n1室1厅1厨1卫1阳台\n\n1\n2\n3\n4\n5\n\n0\n1\n2\n\n1\n\n1\n\n0\n1\n2\n3", null, "", null, "", null, "报名成功，资料已提交审核", null, "A B C D E F G H J K L M N P Q R S T W X Y Z\nA - B - C - D - E\n• A\n• 鞍山\n• 安庆\n• 安阳\n• 安顺\n• 安康\n• 澳门\n• B\n• 北京\n• 保定\n• 包头\n• 巴彦淖尔\n• 本溪\n• 蚌埠\n• 亳州\n• 滨州\n• 北海\n• 百色\n• 巴中\n• 毕节\n• 保山\n• 宝鸡\n• 白银\n• 巴州\n• C\n• 承德\n• 沧州\n• 长治\n• 赤峰\n• 朝阳\n• 长春\n• 常州\n• 滁州\n• 池州\n• 长沙\n• 常德\n• 郴州\n• 潮州\n• 崇左\n• 重庆\n• 成都\n• 楚雄\n• 昌都\n• 慈溪\n• 常熟\n• D\n• 大同\n• 大连\n• 丹东\n• 大庆\n• 东营\n• 德州\n• 东莞\n• 德阳\n• 达州\n• 大理\n• 德宏\n• 定西\n• 儋州\n• 东平\n• E\n• 鄂尔多斯\n• 鄂州\n• 恩施\nF - G - H - I - J\n• F\n• 抚顺\n• 阜新\n• 阜阳\n• 福州\n• 抚州\n• 佛山\n• 防城港\n• G\n• 赣州\n• 广州\n• 桂林\n• 贵港\n• 广元\n• 广安\n• 贵阳\n• 固原\n• H\n• 邯郸\n• 衡水\n• 呼和浩特\n• 呼伦贝尔\n• 葫芦岛\n• 哈尔滨\n• 黑河\n• 淮安\n• 杭州\n• 湖州\n• 合肥\n• 淮南\n• 淮北\n• 黄山\n• 菏泽\n• 鹤壁\n• 黄石\n• 黄冈\n• 衡阳\n• 怀化\n• 惠州\n• 河源\n• 贺州\n• 河池\n• 海口\n• 红河\n• 汉中\n• 海东\n• 怀来\n• I\n• J\n• 晋中\n• 锦州\n• 吉林\n• 鸡西\n• 佳木斯\n• 嘉兴\n• 金华\n• 景德镇\n• 九江\n• 吉安\n• 济南\n• 济宁\n• 焦作\n• 荆门\n• 荆州\n• 江门\n• 揭阳\n• 金昌\n• 酒泉\n• 嘉峪关\nK - L - M - N - P\n• K\n• 开封\n• 昆明\n• 昆山\n• L\n• 廊坊\n• 临汾\n• 辽阳\n• 连云港\n• 丽水\n• 六安\n• 龙岩\n• 莱芜\n• 临沂\n• 聊城\n• 洛阳\n• 漯河\n• 娄底\n• 柳州\n• 来宾\n• 泸州\n• 乐山\n• 六盘水\n• 丽江\n• 临沧\n• 拉萨\n• 林芝\n• 兰州\n• 陇南\n• M\n• 牡丹江\n• 马鞍山\n• 茂名\n• 梅州\n• 绵阳\n• 眉山\n• N\n• 南京\n• 南通\n• 宁波\n• 南平\n• 宁德\n• 南昌\n• 南阳\n• 南宁\n• 内江\n• 南充\n• P\n• 盘锦\n• 莆田\n• 平顶山\n• 濮阳\n• 攀枝花\n• 普洱\n• 平凉\nQ - R - S - T - W\n• Q\n• 秦皇岛\n• 齐齐哈尔\n• 衢州\n• 泉州\n• 青岛\n• 清远\n• 钦州\n• 黔南\n• 曲靖\n• 庆阳\n• R\n• 日照\n• 日喀则\n• S\n• 石家庄\n• 沈阳\n• 双鸭山\n• 绥化\n• 上海\n• 苏州\n• 宿迁\n• 绍兴\n• 宿州\n• 三明\n• 上饶\n• 三门峡\n• 商丘\n• 十堰\n• 随州\n• 邵阳\n• 韶关\n• 深圳\n• 汕头\n• 汕尾\n• 三亚\n• 三沙\n• 遂宁\n• 山南\n• 商洛\n• 石嘴山\n• T\n• 天津\n• 唐山\n• 太原\n• 通辽\n• 铁岭\n• 泰州\n• 台州\n• 铜陵\n• 泰安\n• 铜仁\n• 铜川\n• 天水\n• 天门\n• W\n• 乌海\n• 乌兰察布\n• 无锡\n• 温州\n• 芜湖\n• 潍坊\n• 威海\n• 武汉\n• 梧州\n• 渭南\n• 武威\n• 吴忠\n• 乌鲁木齐\nX - Y - Z\n• X\n• 邢台\n• 徐州\n• 宣城\n• 厦门\n• 新乡\n• 许昌\n• 信阳\n• 襄阳\n• 孝感\n• 咸宁\n• 湘潭\n• 湘西\n• 西双版纳\n• 西安\n• 咸阳\n• 西宁\n• 仙桃\n• 西昌\n• Y\n• 运城\n• 营口\n• 盐城\n• 扬州\n• 鹰潭\n• 宜春\n• 烟台\n• 宜昌\n• 岳阳\n• 益阳\n• 永州\n• 阳江\n• 云浮\n• 玉林\n• 宜宾\n• 雅安\n• 玉溪\n• 延安\n• 榆林\n• 银川\n• Z\n• 张家口\n• 镇江\n• 舟山\n• 漳州\n• 淄博\n• 枣庄\n• 郑州\n• 周口\n• 驻马店\n• 株洲\n• 张家界\n• 珠海\n• 湛江\n• 肇庆\n• 中山\n• 自贡\n• 资阳\n• 遵义\n• 昭通\n• 张掖\n• 中卫", null, "", null, "• 手机", null, "• 分享\n• 设计\n免费设计\n• 计算器\n装修计算器\n• 入驻\n合作入驻\n• 联系\n联系我们\n• 置顶\n返回顶部" ]

[ null, "https://t1.focus-img.cn/sh740wsh/zx/xw/bf7992aecad613484c24662905121509.jpg", null, "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAABLEAAAAKCAYAAABL/czxAAACeklEQVR4Xu3cwUoCYRTF8RmSmUUE6QOICwkqkCFECJ/Dp/Q53MYgVBAuxAfQIFrMYBCjTIylQkTq4reVD5TLuef8vzvODXu93v18Pn+YTCZZEARBp9M5j+P4ptVqPQyHw4/isyRJLqMounZOXehAf/ADPikX5CU+wE04ERe7L7gfuTe6J5sfmJccY44UttvtuF6vdxaLxbj8Af1+/2K5XF41m820BFXngkBdgoAO6KAIKzqgAzpYD7LkAj+ggzXAywV+QAdywb3Rfdr8wFzlEHOkUOAIHIEjcASOwDlE4Hhg4gGRQYdBB+7EnbgTd+JO3Ik7/ZHoLw+CV0MsQAEoAAWgABSAAlAAir8AhQGVARWexJN4Ek/iSTyJJ/Hkf/NkWLzLPB6P3/eBR5Zl13mePzq3GUzqsr1B1UVdCuOiAzqgg92vWOkP/aE/9Ef5Kio/4Af8gB/wA/OI6monubA/F8Jut9uL4/h5NBq97RpkFYOuKIpunducrKvL9sBRF3UplzzyjZ8GrD/0h/7AG9UlqHyST8oFuSAX5IJcMI+o7iiXC/tzIRwMBmez2Syp1Wov+wZZzm0vpLqoSwEedEAHdLAbQPWH/tAf+qO8oPEDfsAP+AE/cO+uDmzkglz4bS6sdmIRDuHQAaAAFIACUHig8335Pj7AB/gAH+ADfIAP8AE+8MefbbtPj8WJX4vdj/UDfC9ABsgAGSADZIAMkAEyQD4lQMan+BSf4lN8ik/x6WnyaZgkyWWapq+lUU+n07ssy56qS9wbjcZdnufPzqkLHegPfjA445PtmA7ooBg40AEd0MH6jQa5wA/oYD34lAv8gA7kQrlr/b/84BMd0gjHDtit4gAAAABJRU5ErkJggg==", null, "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACQAAAAkCAYAAADhAJiYAAACwElEQVRYR+3XT0gUURwH8N97s5qiuEqEilb7lPWwO0g0S3WQsoMlWdHB9hB0kEiJwIjyFkIXCyQqD4V2CBI6bEGBCJZEf/BQsAMhdnAG3XVVVDr4B8XZ0ZlfTLXkbK2z7rogNHvcN+/3PvP9/VjeEkTkYAd9iA2y6IadkNW42gnZCVklYLX+/85Q2Odzu4JBeUckNOHxnNVUNUAovc0k6c5mqIy3bMLjOamp6itAzDYghNIOJsvtiVAZBUW83lpNUfoQIDcGIAA6l5d3aN/w8Nd/oTIGivD8kXVFGQDE/A0YJBx3ySVJz9JKaKalZVdpd3fUaiBj65M8f3BtdXUQAJymPZRerZDl7rRmKOz1nsZo9BHk5JxiIyMjVqgQz/OgKO8QcffGZ4nDcZONjj6w2r9py8IeT6Ouqr2AmEUA5mhh4fH9oiglKjohCFX6wsJ7BCg2YTiunUlShxXm59AnuqBFqqsPaCsrXxDgz42SkOlsp7O2XBRD8cWnBIGpi4sfALFs4xql9K5Llm8lg9kUZCyOV1XdA027ZnpbgHBOUdGx0mBwOvb9jM9XpszPf0QAl+lgjntYIUk3ksVYgowHQm73Y9T1y6aihMhZJSW1e4eG5iZraorXZmeNZNwmOKVPmCxf2QomKdBv1FPU9YtxqG+OggL/+tJSABC9cZheJstNW8UkDYKeHhrq7HyOut4Y1z7NNGO/folfsra2C9DcrGcOZFRubXWE+vtfIMCZRAcRgD7W0HAeurrWU8Ekn1Csut+fHRLF1whwIv5AAvCWCcI5CATUVDFbBwHAd78/d1kU+xHgaOxgAvApXxAa9gQCq+lgUgIZm+br6vIXxsffIMBhQsjnQsbqiwYHl9PFpAwyNk7V1zvXxsbuZ1VWXi8fGFjcDkxaoO0C/DWL9n97i2gzdkFLtaU2yCo5OyGrhH4AtD5LNJ/vw8QAAAAASUVORK5CYII=", null, "https://xinyang.home.focus.cn/gonglue/07ab600ad843955d.html", null, "https://t1.focus-res.cn/front-pc/module/loupan-baoming/images/yes.png", null, "https://t1.focus-res.cn/front-pc/module/loupan-baoming/images/qrcode.png", null, "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACQAAAAkCAYAAADhAJiYAAACwElEQVRYR+3XT0gUURwH8N97s5qiuEqEilb7lPWwO0g0S3WQsoMlWdHB9hB0kEiJwIjyFkIXCyQqD4V2CBI6bEGBCJZEf/BQsAMhdnAG3XVVVDr4B8XZ0ZlfTLXkbK2z7rogNHvcN+/3PvP9/VjeEkTkYAd9iA2y6IadkNW42gnZCVklYLX+/85Q2Odzu4JBeUckNOHxnNVUNUAovc0k6c5mqIy3bMLjOamp6itAzDYghNIOJsvtiVAZBUW83lpNUfoQIDcGIAA6l5d3aN/w8Nd/oTIGivD8kXVFGQDE/A0YJBx3ySVJz9JKaKalZVdpd3fUaiBj65M8f3BtdXUQAJymPZRerZDl7rRmKOz1nsZo9BHk5JxiIyMjVqgQz/OgKO8QcffGZ4nDcZONjj6w2r9py8IeT6Ouqr2AmEUA5mhh4fH9oiglKjohCFX6wsJ7BCg2YTiunUlShxXm59AnuqBFqqsPaCsrXxDgz42SkOlsp7O2XBRD8cWnBIGpi4sfALFs4xql9K5Llm8lg9kUZCyOV1XdA027ZnpbgHBOUdGx0mBwOvb9jM9XpszPf0QAl+lgjntYIUk3ksVYgowHQm73Y9T1y6aihMhZJSW1e4eG5iZraorXZmeNZNwmOKVPmCxf2QomKdBv1FPU9YtxqG+OggL/+tJSABC9cZheJstNW8UkDYKeHhrq7HyOut4Y1z7NNGO/folfsra2C9DcrGcOZFRubXWE+vtfIMCZRAcRgD7W0HAeurrWU8Ekn1Csut+fHRLF1whwIv5AAvCWCcI5CATUVDFbBwHAd78/d1kU+xHgaOxgAvApXxAa9gQCq+lgUgIZm+br6vIXxsffIMBhQsjnQsbqiwYHl9PFpAwyNk7V1zvXxsbuZ1VWXi8fGFjcDkxaoO0C/DWL9n97i2gzdkFLtaU2yCo5OyGrhH4AtD5LNJ/vw8QAAAAASUVORK5CYII=", null, "https://t.focus-res.cn/home-front/pc/img/qrcode.d7cfc15.png", null, "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAG8AAABvAQAAAADKvqPNAAABdUlEQVR42rWVMY6FIBCGx1DQ6QVIuAYdV9ILiF5ArkTHNUi4gHYUZGcHfS/ZZplX7BoLvgKZf/j/EfDn8wV/iBVA+6hWW2eAlUOHagW1RLywsjhLBVJsRl9BfYB6M+Kw4jNUrsAq6/IBUlWjxc3C8i6yg9Dqb+9bfgepf3UKdbT0kaexHaSFuJD2ilMKDtGXfBqYgnKYWbyKGhD3AEMgCX2so2mSl5D9U1UXlwAuoqcWySa/i3javMnsQ11u+V2sS9RIPil1ahIYHIHqxz3WodwSekhrcRg1G30Cj6dNE8Jqso+JRV/EVXAvdBB+MVhdaM1shnlM2EM8DWVB7yUNoV1oHzeZZsgHkAmRwzpFshNZJVEqOcTN5Nu32RfNIQ0ENVtNdwRwh72HLQsrqWjCX9H4HVtbwGgsZLDMokO9WfQhufgMqB7SGPHtCDqr7eVQOXJ4gZciBvVJMwoS5Z3FFjGaIVIfFlgkvQNWCu/QLquP//ab+AYSM5R75r4IFgAAAABJRU5ErkJggg==", null ]

[ "2 / 4\nCASIO SCIENTIFIC CALCULATOR FX-570MS 2ND EDITION\nRM 69.90\n3 in stock\nSelect Option\nNew fx-570MS 2nd Edition\n\n401 Functions / Dot Matrix\n2-Line Display / 10+2 Digits / Plastic Keys\nMulti-replay function , Matrix calculations , Equation calculations , Vector calculations , Differential calculations , SOLVE function\n\nSTANDARD MODEL SPECIFICATIONS\n401 Functions\nS-V.P.A.M. ~super visually perfect algebraic method\nFraction Calculations\nCombination and permutation\nStatistics (STAT-data editor, Standard deviation, Regression analysis)\n9 Variables\nMulti-replay\nEquation calculations, Vector calculations, Differential calculations, SOLVE function\nIntegration calculations\nBase-n calculations/ conversions\nComplex number calculations\nLogical operations\nMatrix calculations\nEngineering symbol calculations\n40 Scientific calculations\n40 Matrix conversions (20 conversion pairs)\nCALC memory\n2-Line Display\n10+2 Digits\nDot Matrix\nPlastic Keys\nComes with slide-on hard case" ]

[ null ]

[ "Holomorphic forms, the $\\bar{\\partial}$-equation, and duality on a reduced complex space Artikel i övriga tidskrifter, 2015\n\nWe study two natural notions of holomorphic forms on a reduced pure $n$-dimensional complex space $X$: sections of the sheaves $\\Omega_X^{\\bullet}$ of germs of holomorphic forms on $X_{reg}$ that have a holomorphic extension to some ambient complex manifold, and sections of the sheaves $\\omega_X^{\\bullet}$ introduced by Barlet. We show that $\\Omega_X^p$ and $\\omega_X^{n-p}$ are Serre dual to each other in a certain sense. We also provide explicit, intrinsic and semi-global Koppelman formulas for the $\\bar{\\partial}$-equation on $X$ and introduce fine sheaves $\\mathscr{A}_X^{p,q}$ and $\\mathscr{B}_X^{p,q}$ of $(p,q)$-currents on $X$, that are smooth on $X_{reg}$, such that $(\\mathscr{A}_X^{p,\\bullet},\\bar{\\partial})$ is a resolution of $\\Om_X^p$ and, if $\\Omega_X^{n-p}$ is Cohen-Macaulay, $(\\mathscr{B}_X^{p,\\bullet},\\bar{\\partial})$ is a resolution of $\\omega_X^{p}$.\n\nFörfattare\n\nHåkan Samuelsson Kalm\n\nGöteborgs universitet\n\nChalmers, Matematiska vetenskaper, Matematik\n\nÄmneskategorier\n\nMatematik\n\nGeometri\n\nMatematisk analys\n\n2018-12-13" ]

[ null ]

[ "# 304: Itinerary Choice using Ordered GEV¶\n\nThis example is an itinerary choice model built using the example itinerary choice dataset included with Larch. As usual, we first create the DB objects:\n\nd = larch.DB.Example('AIR')\n\n\nAs with the nested logit, we need to renumber the alternatives. In this example, we will be grouping on finer time of day groups, so our numbering system must account for this:\n\nfrom enum import IntEnum\n\nclass time_of_day(IntEnum):\ntp1 = 1\ntp2 = 2\ntp3 = 3\ntp4 = 4\ntp5 = 5\ntp6 = 6\ntp7 = 7\ntp8 = 8\ntp9 = 9\n\nfrom larch.util.numbering import numbering_system\nns = numbering_system(time_of_day)\n\n\nThen we can use a special command on the DB object to assign new alternative numbers.\n\nd.recode_alts(ns, 'data', 'id_case', 'itinerarycode_ogev1',\n'timeperiod',\nnewaltstable='itinerarycodes_ogev1',\n)\n\n\nAs arguments to this command, we provide the numbering system object, the name of the table that contains the idca data to be numbered (here data), the name of the column in that table that names the caseids, and the name of a new column to be created (or overwritten) with the new code numbers. We also need to give a set of SQL expressions that can be evaluated on the rows of the table to get the categorical values that we defined in the Enums above. In this example, we give just one terms: timeperiod, which already contains our 9 time periods exactly in the correct format. Lastly, we can pass the name of a new table that will be created to identify every observed alternative code.\n\nOnce we have completed the preparation of the data, we can build out model.\n\nNow let’s make our model. The utility function we will use is the same as the one we used for the MNL version of the model.\n\nm = larch.Model(d)\n\nvars = [\n\"timeperiod=2\",\n\"timeperiod=3\",\n\"timeperiod=4\",\n\"timeperiod=5\",\n\"timeperiod=6\",\n\"timeperiod=7\",\n\"timeperiod=8\",\n\"timeperiod=9\",\n\"carrier=2\",\n\"carrier=3\",\n\"carrier=4\",\n\"carrier=5\",\n\"equipment=2\",\n\"fare_hy\",\n\"fare_ly\",\n\"elapsed_time\",\n\"nb_cnxs\",\n]\nfrom larch.roles import PX\nm.utility.ca = sum(PX(i) for i in vars)\n\n\nTo build a simple OGEV model with balanced allocations, we can use a similar the looping structure as we used in the NL model:\n\n# Ensure time periods are sorted\ntime_of_day_s = sorted(time_of_day)\n# Overlapping nests\nfor tod1, tod2 in zip(time_of_day_s[:], time_of_day_s[1:]):\ntod_nest = m.new_nest(tod1.name+tod2.name, param_name=\"mu_tod\", parent=m.root_id)\nfor a in d.alternative_codes():\nif ns.code_matches_attributes(a, tod1) or ns.code_matches_attributes(a, tod2):\n# First and last nest\nfor tod in (time_of_day_s, time_of_day_s[-1]):\ntod_nest = m.new_nest(tod.name+\"only\", param_name=\"mu_tod\", parent=m.root_id)\nfor a in d.alternative_codes():\nif ns.code_matches_attributes(a, tod):\n\n\nTo estimate the likelihood maximizing parameters, again we give:\n\n>>> result = m.maximize_loglike('SLSQP', metaoptions={'ftol': 1e-10}, ctol=1e-10)\n\n>>> print(m.report('txt', sigfigs=3))\n============================================================================================...\nModel Parameter Estimates\n--------------------------------------------------------------------------------------------...\ntimeperiod=2 0.0 0.213 0.00914 23.3 0.0\ntimeperiod=3 0.0 0.248 0.00967 25.7 0.0\ntimeperiod=4 0.0 0.193 0.01 19.3 0.0\ntimeperiod=5 0.0 0.238 0.00956 24.9 0.0\ntimeperiod=6 0.0 0.333 0.00948 35.1 0.0\ntimeperiod=7 0.0 0.448 0.00961 46.6 0.0\ntimeperiod=8 0.0 0.371 0.00963 38.5 0.0\ntimeperiod=9 0.0 0.0572 0.0106 5.41 0.0\ncarrier=2 0.0 0.0952 0.00691 13.8 0.0\ncarrier=3 0.0 0.491 0.0083 59.2 0.0\ncarrier=4 0.0 0.438 0.0147 29.9 0.0\ncarrier=5 0.0 -0.508 0.0111 -45.6 0.0\nequipment=2 0.0 0.379 0.00811 46.7 0.0\nfare_hy 0.0 -0.000941 2.41e-05 -39.1 0.0\nfare_ly 0.0 -0.000972 6.87e-05 -14.2 0.0\nelapsed_time 0.0 -0.00476 0.000102 -46.7 0.0\nnb_cnxs 0.0 -2.33 0.0307 -75.9 0.0\nmu_tod 1.0 0.782 0.00795 -27.4 1.0\n============================================================================================...\nModel Estimation Statistics\n--------------------------------------------------------------------------------------------...\nLog Likelihood at Convergence -777441.22\nLog Likelihood at Null Parameters -953940.44\n--------------------------------------------------------------------------------------------...\nRho Squared w.r.t. Null Parameters 0.185\n============================================================================================...\n\n\nTip\n\nIf you want access to the model in this example without worrying about assembling all the code blocks together on your own, you can load a read-to-estimate copy like this:\n\nm = larch.Model.Example(304)" ]

[ null ]

[ "Search a number\nMoran numbers\nA number", null, "is a Moran number if", null, "divided by the sum of its digits gives a prime number.\n\nFor example, 111 is a Moran number because 111/(1+1+1) = 37 and 37 is a prime number.\n\nMoran numbers are a subset of Harshad numbers.\n\nThe first pair of consecutive Moran numbers is (152, 153, while the first runs of length 3, 4, 5 and 6 start at 3031, 21481224, 25502420, and 4007565001480, respectively. For this last value we have", null, "(I found this number in October 2010: let me know if it appeared somewhere before.)\n\nThe first Moran numbers are 18, 21, 27, 42, 45, 63, 84, 111, 114, 117, 133, 152, 153, 156, 171, 190, 195, 198, 201, 207, 209, 222, 228 more terms\n\nMoran numbers can also be... (you may click on names or numbers and on + to get more values)" ]

[ null, "http://www.numbersaplenty.com/set/Moran_number/pic.1.png", null, "http://www.numbersaplenty.com/set/Moran_number/pic.1.png", null, "http://www.numbersaplenty.com/set/Moran_number/pic.2.png", null ]

[ "## Nuclear Engineering ETDs\n\nSpring 4-28-2020\n\n#### Abstract\n\nMethods of stochastic neutron transport are investigated and applied to novel formulations for the neutron number distribution and the cumulative fission energy deposition distribution. We utilize two Monte Carlo algorithms: the event-based Monte Carlo (EBMC) method and the Stochastic Simulation Algorithm (SSA) to benchmark and analyze systems. We show that the SSA outperforms the EBMC for the parameter space we are interested in. We then utilize the SSA to analyze systems composed of multiple spherical regions with fast and thermal neutrons with time-dependent reactivity insertions and determine whether group-dependent number distributions approach a gamma distribution. We develop two methods for calculating the geometry-dependent transfer probabilities, the View Factor Approximation and the Sphere Point Picking Monte Carlo Method, and compare the parametric space for which the computationally superior VF approximation holds. We discuss several numerical solution methods that have been developed for solving the nonlinear adjoint transport equation satisfied by the neutron survival probability. We show the primary competitive direct solution referred to as the $\\lambda$-Acceleration Method ($\\lambda$AM), and introduce a new indirect solution method called the Eigenfunction Expansion Method (EFE). The space-angle shape of the solution in a nonhomogeneous planar medium equilibrate rapidly after the initiation of a chain and for practical purposes 3 modes are sufficient to accurately capture the time variation of the survival probability, with a full fission neutron multiplicity distribution, while just 1 mode gives acceptable accuracy in steady state. The order of the nonlinearity, correlated to the induced fission chain branching, has a larger effect on the solution than the number of modes retained in the expansion. In particular, the quadratic approximation, corresponding to truncation order 2 in the nonlinear fission branching terms, is accurate for near critical systems but nonlinearity orders of 4 to 5 are necessary for more strongly supercritical media. Comparison of numerical results against the $\\lambda$AM establish the quantitative accuracy and computational efficiency achievable with the EFE approach.\n\nWe derive space, angle, and time-dependent single chain a source equations for the cumulative energy deposition distribution (the FPDF) in a system via the backward Master equation formulation; from which, equations of the moments are also derived. This new formulation has the benefit of not requiring knowledge of the neutron number distribution. We then compare results of the EBMC method with the direct numerical solution of the moment equations and show excellent agreement. We then show that by altering the induced fission energy deposition distribution, the first four moments are virtually the same for supercritical systems. It is shown that the FPDF itself does indeed have noticeable alterations in the high energy deposition tails of the distribution, suggesting that one may need to consider higher order moments in order to witness a noticeable difference in the respective profile. It was also shown that the multiplicity distribution model being used, where we compared the full distribution with the MCNP mean-preserving model, has an effect on the higher energy deposition region of the single chain FPDF.\n\nFinally, we formulate the Boltzmann Master equation- a novel nonlinear adjoint transport equation satisfied by the neutron number density distribution. In a lumped system setting, we consider several numerical discretization schemes for the number distribution, which show that typical basis and test functions used in transport methods are not robust. We apply the collocation method as well as derive an analytical generalization of Bell's distribution via solution ansatz. We then expand our scope to include space and angle dependence, derived systems of equations for the aforementioned discretization schemes, and compared the results, showing excellent agreement for long enough times in supercritical systems with the Quadratic Approximation applied.\n\n#### Keywords\n\nstochastic simulation algorithm, Master equations, Monte Carlo methods, Boltzmann Master equation, neutron transport\n\nDissertation\n\nEnglish\n\n#### Degree Name\n\nNuclear Engineering\n\nDoctoral\n\n#### Department Name\n\nNuclear Engineering\n\nAnil Prinja\n\nForrest Brown\n\n#### Third Committee Member\n\nChristopher Perfetti\n\nDimiter Petsev\n\nErin Davis\n\nCOinS" ]

[ null ]

[ "# Python练习题\n\n输入一个正整数N (N≤100)，输出 每行输出一个完美立方。输出格式为： Cube = a, Triple = (b,c,d) 其中a,b,c,d所在位置分别用实际求出四元组值代入。 　　请按照a的值，从小到大依次输出。当两个完美立方 等式中a的值相同，则b值小的优先输出，仍相同则c值小的优先输出，再相同则d值小的先输出。\n\nn = int(input())\ncube = \nfor i in range(2, n+1):\ncube.append(i**3)\nfor a in range(3,n):\nfor b in range(0,a-2):\nif cube[a] < (cube[b] + cube[b+1] + cube[b+2]):\nbreak\nfor c in range(b+1,a-1):\nif cube[a] < (cube[b] + cube[c] + cube[c+1]):\nbreak\nfor d in range(c+1,a):\nif cube[a] == (cube[b] + cube[c] + cube[d]):\nprint(\"Cube = %d,Tripe = (%d,%d,%d)\" %(a+1,b+1,c+1,d+1))\n\n\n输入格式为：USD10，输出格式为：RMB67.8（注意中间没有是空格的）。\n\nstr1=input()\nimport re\nnum=int(''.join(re.findall('\\d+',str1)))\nif 'RMB' in str1:\nprint('USD','%.2f' %(num/6.78),sep='')\nelif 'USD' in str1:\nprint('RMB','%.2f' %(num*6.78),sep='')\n\n\n比如 ‘xyz’ 会变成 ‘abc’ 。\n\noriginal=input()\ncipher=''\nfor i in original:\na=ord(i)\nif 97<=a<=119:\ncipher+=chr(a+3)\nelif 120<=a<=122:\ncipher+=chr(a+3-26)\nelse:\ncipher+=i\nprint(cipher)\n\n\n获得用户输入N，计算每天努力和每天放任365天后的能力值及能力间比值，其中，能力值保留小数点后2位，能力间比值输出整数，输出结果间采用英文逗号分隔。\n\n代码如下：\n\n1 percent=eval(input())\n2 hard=sunning=1\n3 for i in range(2,366):\n4 hard*=(1+percent/1000)\n5 sunning*=(1-percent/1000)\n6 print('%.2f,%.2f,%d' %(hard,sunning,hard/sunning))\n\n\n例如: 19 就是一个快乐的数字，计算过程如下：\n\n12 + 92 = 82 82 + 22 = 68 62 + 82 = 100 12 + 02 + 02 = 1 　　当输入时快乐的数字时，输出True，否则输出False。\n\n代码如下：\n\n 1 num=eval(input())\n2 list1=[]\n3 while (num not in list1) and (num!=1):\n4 list1.append(num)\n5 a=num%10\n6 b=num//10%10\n7 c=num//100\n8 num=a**2+b**2+c**2 9 if num==1:\n10 print('True')\n11 else:\n12 print('False')\n\n\n输入台阶数，输出一共有多少种跳法。\n\n注意：如果运算超时，请思考有什么办法降低时间复杂度。\n\n代码如下：（递归，可能会超出时间上限）\n\n 1 def wawa(step):\n2 if step==1:\n3 way=1\n4 elif step==2:\n5 way=2\n6 else:\n7 way=wawa(step-1)+wawa(step-2)\n8 return way\n9\n10 step=eval(input())\n11 print(wawa(step))\n\n\n代码如下：\n\n1 flag=1\n2 while flag:\n4 try:\n7 print('A')\n9 print('B')\n11 print('C')\n13 print('D')\n15 print('E')\n17 print('end')\n18 flag=0\n19 else:\n20 print('data error!')\n21 except:\n22 print('data error!')\n\n\n本题要求实现一个函数，判断参数是否是质数，是的话返回True，否则返回False。\n\n代码如下：\n\n1 def isPrime(num):\n2 import math\n3 for i in range(2,int(math.sqrt(num))+1):\n4 if num%i==0:\n5 return 0\n6 return 1\n7\n8 num=int(input())\n9 if isPrime(num):\n10 print('yes')\n11 else:\n12 print('no')\n\n\n代码如下：\n\n1 months={1: 'Jan.',2:'Feb.',3:'Mar.',4:'Apr.',5:'May.',6:'Jun.',7:'Jul.',8:'Aug.',9:'Sep.',10:'Oct.',11:'Nov.',12:'Dec.'}\n2 str1=int(input())\n3 print(months[str1])\n\n\n输入x，按上述分段函数求解。如果输入超出范围的x则输出“ERROR” 。\n\n代码如下：\n\n1 x=eval(input())\n2 if -1<x<=0:\n3 print('f(x)=-10')\n4 elif 0<x<=1:\n5 print('f(x)=5')\n6 elif 1<x<=2:\n7 print('f(x)=9.6')\n8 else:\n9 print('ERROR')\n\n\n世纪年（能被100整除的年份）能被400整除的是闰年。(如2000年是闰年，1900年不是闰年)；\n\n用户输入一个正整数，代表年份，输出该年有多少天？\n\n代码如下：\n\n 1 year=int(input())\n2 if year%100==0:#世纪年\n3 if year%400==0:\n4 print('366')\n5 else:\n6 print('365')\n7 else:\n8 if year%4==0:\n9 print('366')\n10 else:\n11 print('365')\n\n\n代码如下：\n\n1 str1='Qs2X'\n2 str2=input()\n3 if str1.lower()==str2.lower():\n4 print('验证码正确')\n5 else:\n6 print('验证码错误，请重新输入')\n\n\n代码如下：（这个真的是简单到不想发上来、、、、、）\n\n1 i=int(input())\n2 s=0\n3 for i in range(1,i*2,2):\n4 s=s+i\n5 print(s)" ]

[ null ]

[ "### IMO Shortlist 2004 problem G4\n\nKvaliteta:\nAvg: 0.0\nTežina:\nAvg: 7.0\nIn a convex quadrilateral", null, "$ABCD$, the diagonal", null, "$BD$ bisects neither the angle", null, "$ABC$ nor the angle", null, "$CDA$. The point", null, "$P$ lies inside", null, "$ABCD$ and satisfies", null, "Prove that", null, "$ABCD$ is a cyclic quadrilateral if and only if", null, "$AP=CP$.\nSource: Međunarodna matematička olimpijada, shortlist 2004" ]

[ null, "https://skoljka.org/media/m/9/c/e/9ce25711ba18d9663b73c3580de4bf5a.png ", null, "https://skoljka.org/media/m/1/1/f/11f65a804e5c922ee28a53b1df04d138.png ", null, "https://skoljka.org/media/m/a/c/7/ac75dca5ddb22ad70f492e2e0a153f95.png ", null, "https://skoljka.org/media/m/d/1/9/d19754e826d51d8da2971e0b887d590c.png ", null, "https://skoljka.org/media/m/9/6/8/968d210d037e7e95372de185e8fb8759.png ", null, "https://skoljka.org/media/m/9/c/e/9ce25711ba18d9663b73c3580de4bf5a.png ", null, "https://skoljka.org/media/m/5/7/a/57ab1749c546e7cfe65162bb54b5c0a4.png", null, "https://skoljka.org/media/m/9/c/e/9ce25711ba18d9663b73c3580de4bf5a.png ", null, "https://skoljka.org/media/m/c/9/b/c9bcdd5c425926dc9f03571a1b755233.png ", null ]

[ "# R/getCI.R In salbm: Sensitivity Analysis for Binary Missing Data\n\n#### Documented in getCI\n\n```getCI <- function( Res, ci=c(\"lb4\",\"ub4\") ) {\nECI <- Res\\$ECI\nSCI <- Res\\$SCI\nK <- Res\\$K\nalphas <- Res\\$alphas\n\nkpnms <- c(\"alpha1\",\"Est\",ci)\nER1 <- ECI[ ECI[,\"k\"] == K & ECI[,\"trt\"] == 1 & ECI[,\"alpha1\"] == ECI[,\"alpha2\"], kpnms]\nER2 <- ECI[ ECI[,\"k\"] == K & ECI[,\"trt\"] == 2 & ECI[,\"alpha1\"] == ECI[,\"alpha2\"], kpnms]\nERD <- ECI[ ECI[,\"k\"] == K & ECI[,\"trt\"] == 0 & ECI[,\"alpha1\"] == ECI[,\"alpha2\"], kpnms]\n\nSR1 <- SCI[ SCI[,\"k\"] == K & SCI[,\"trt\"] == 1 & SCI[,\"alpha1\"] == SCI[,\"alpha2\"], kpnms]\nSR2 <- SCI[ SCI[,\"k\"] == K & SCI[,\"trt\"] == 2 & SCI[,\"alpha1\"] == SCI[,\"alpha2\"], kpnms]\nSRD <- SCI[ SCI[,\"k\"] == K & SCI[,\"trt\"] == 0 & SCI[,\"alpha1\"] == SCI[,\"alpha2\"], kpnms]\n\nreturn( list( K=K, alphas=alphas, ER1 = ER1, ER2 = ER2, ERD = ERD, SR1 = SR1, SR2 = SR2, SRD = SRD ) )\n}\n```\n\n## Try the salbm package in your browser\n\nAny scripts or data that you put into this service are public.\n\nsalbm documentation built on May 25, 2021, 9:07 a.m." ]

[ null ]

[ "```[email protected] list mirror (unofficial, one of many)\nhelp / color / mirror / code / Atom feed```\n```* [PATCH 00/13] reftable library\n@ 2020-09-16 19:10 Han-Wen Nienhuys via GitGitGadget\n` (13 more replies)\n0 siblings, 14 replies; 251+ messages in thread\nFrom: Han-Wen Nienhuys via GitGitGadget @ 2020-09-16 19:10 UTC (permalink / raw)\nTo: git; +Cc: Han-Wen Nienhuys\n\nThis splits the giant commit from\nhttps://github.com/gitgitgadget/git/pull/539 into a series of smaller\ncommits, which build and have unittests.\n\nThe final commit should also be split up, but I want to wait until we have\nconsensus that the bottom commits look good.\n\nHan-Wen Nienhuys (12):\nreftable: define the public API\nreftable: add a barebones unittest framework\nreftable: utility functions\nreftable: (de)serialization for the polymorphic record type.\nreftable: a generic binary tree implementation\nreftable: write reftable files\nreftable: file level tests\nreftable: rest of library\nreftable: \"test-tool dump-reftable\" command.\n\nJohannes Schindelin (1):\nvcxproj: adjust for the reftable changes\n\nMakefile | 46 +-\nconfig.mak.uname | 2 +-\ncontrib/buildsystems/Generators/Vcxproj.pm | 11 +-\nreftable/.gitattributes | 1 +\nreftable/VERSION | 1 +\nreftable/basics.c | 131 +++\nreftable/basics.h | 48 +\nreftable/block.c | 443 +++++++\nreftable/block.h | 129 +++\nreftable/block_test.c | 158 +++\nreftable/blocksource.c | 148 +++\nreftable/blocksource.h | 22 +\nreftable/compat.c | 110 ++\nreftable/compat.h | 48 +\nreftable/constants.h | 21 +\nreftable/dump.c | 212 ++++\nreftable/iter.c | 242 ++++\nreftable/iter.h | 72 ++\nreftable/merged.c | 358 ++++++\nreftable/merged.h | 39 +\nreftable/merged_test.c | 331 ++++++\nreftable/pq.c | 115 ++\nreftable/pq.h | 34 +\nreftable/publicbasics.c | 100 ++\nreftable/record.c | 1114 ++++++++++++++++++\nreftable/record.h | 143 +++\nreftable/record_test.c | 410 +++++++\nreftable/refname.c | 209 ++++\nreftable/refname.h | 38 +\nreftable/refname_test.c | 100 ++\nreftable/reftable-tests.h | 22 +\nreftable/reftable.c | 104 ++\nreftable/reftable.h | 585 ++++++++++\nreftable/reftable_test.c | 585 ++++++++++\nreftable/stack.c | 1224 ++++++++++++++++++++\nreftable/stack.h | 50 +\nreftable/stack_test.c | 787 +++++++++++++\nreftable/strbuf.c | 142 +++\nreftable/strbuf.h | 80 ++\nreftable/strbuf_test.c | 37 +\nreftable/system.h | 51 +\nreftable/test_framework.c | 68 ++\nreftable/test_framework.h | 60 +\nreftable/tree.c | 63 +\nreftable/tree.h | 34 +\nreftable/tree_test.c | 62 +\nreftable/update.sh | 22 +\nreftable/writer.c | 664 +++++++++++\nreftable/writer.h | 60 +\nreftable/zlib-compat.c | 92 ++\nt/helper/test-reftable.c | 20 +\nt/helper/test-tool.c | 2 +\nt/helper/test-tool.h | 2 +\n56 files changed, 10489 insertions(+), 5 deletions(-)\ncreate mode 100644 reftable/.gitattributes\ncreate mode 100644 reftable/VERSION\ncreate mode 100644 reftable/basics.c\ncreate mode 100644 reftable/basics.h\ncreate mode 100644 reftable/block.c\ncreate mode 100644 reftable/block.h\ncreate mode 100644 reftable/block_test.c\ncreate mode 100644 reftable/blocksource.c\ncreate mode 100644 reftable/blocksource.h\ncreate mode 100644 reftable/compat.c\ncreate mode 100644 reftable/compat.h\ncreate mode 100644 reftable/constants.h\ncreate mode 100644 reftable/dump.c\ncreate mode 100644 reftable/iter.c\ncreate mode 100644 reftable/iter.h\ncreate mode 100644 reftable/merged.c\ncreate mode 100644 reftable/merged.h\ncreate mode 100644 reftable/merged_test.c\ncreate mode 100644 reftable/pq.c\ncreate mode 100644 reftable/pq.h\ncreate mode 100644 reftable/publicbasics.c\ncreate mode 100644 reftable/record.c\ncreate mode 100644 reftable/record.h\ncreate mode 100644 reftable/record_test.c\ncreate mode 100644 reftable/refname.c\ncreate mode 100644 reftable/refname.h\ncreate mode 100644 reftable/refname_test.c\ncreate mode 100644 reftable/reftable-tests.h\ncreate mode 100644 reftable/reftable.c\ncreate mode 100644 reftable/reftable.h\ncreate mode 100644 reftable/reftable_test.c\ncreate mode 100644 reftable/stack.c\ncreate mode 100644 reftable/stack.h\ncreate mode 100644 reftable/stack_test.c\ncreate mode 100644 reftable/strbuf.c\ncreate mode 100644 reftable/strbuf.h\ncreate mode 100644 reftable/strbuf_test.c\ncreate mode 100644 reftable/system.h\ncreate mode 100644 reftable/test_framework.c\ncreate mode 100644 reftable/test_framework.h\ncreate mode 100644 reftable/tree.c\ncreate mode 100644 reftable/tree.h\ncreate mode 100644 reftable/tree_test.c\ncreate mode 100755 reftable/update.sh\ncreate mode 100644 reftable/writer.c\ncreate mode 100644 reftable/writer.h\ncreate mode 100644 reftable/zlib-compat.c\ncreate mode 100644 t/helper/test-reftable.c\n\nbase-commit: 54e85e7af1ac9e9a92888060d6811ae767fea1bc\nPull-Request: https://github.com/git/git/pull/847\n--\n\n• ```* [PATCH 01/13] reftable: add LICENSE\n2020-09-16 19:10 [PATCH 00/13] reftable library Han-Wen Nienhuys via GitGitGadget\n@ 2020-09-16 19:10 ` Han-Wen Nienhuys via GitGitGadget\n2020-09-16 19:10 ` [PATCH 02/13] reftable: define the public API Han-Wen Nienhuys via GitGitGadget\n` (12 subsequent siblings)\n13 siblings, 0 replies; 251+ messages in thread\nFrom: Han-Wen Nienhuys via GitGitGadget @ 2020-09-16 19:10 UTC (permalink / raw)\nTo: git; +Cc: Han-Wen Nienhuys, Han-Wen Nienhuys\n\n---\n1 file changed, 31 insertions(+)\n\nnew file mode 100644\nindex 0000000000..402e0f9356\n--- /dev/null\n@@ -0,0 +1,31 @@\n+\n+\n+Redistribution and use in source and binary forms, with or without\n+modification, are permitted provided that the following conditions are\n+met:\n+\n+* Redistributions of source code must retain the above copyright notice,\n+this list of conditions and the following disclaimer.\n+\n+* Redistributions in binary form must reproduce the above copyright\n+notice, this list of conditions and the following disclaimer in the\n+documentation and/or other materials provided with the distribution.\n+\n+* Neither the name of Google LLC nor the names of its contributors may\n+be used to endorse or promote products derived from this software\n+without specific prior written permission.\n+\n+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n+\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n--\n\n• ```* [PATCH 02/13] reftable: define the public API\n2020-09-16 19:10 [PATCH 00/13] reftable library Han-Wen Nienhuys via GitGitGadget\n@ 2020-09-16 19:10 ` Han-Wen Nienhuys via GitGitGadget\n2020-09-16 19:10 ` [PATCH 03/13] vcxproj: adjust for the reftable changes Johannes Schindelin via GitGitGadget\n` (11 subsequent siblings)\n13 siblings, 0 replies; 251+ messages in thread\nFrom: Han-Wen Nienhuys via GitGitGadget @ 2020-09-16 19:10 UTC (permalink / raw)\nTo: git; +Cc: Han-Wen Nienhuys, Han-Wen Nienhuys\n\n---\nreftable/reftable.h | 585 ++++++++++++++++++++++++++++++++++++++++++++\n1 file changed, 585 insertions(+)\ncreate mode 100644 reftable/reftable.h\n\ndiff --git a/reftable/reftable.h b/reftable/reftable.h\nnew file mode 100644\nindex 0000000000..5f8ebf5540\n--- /dev/null\n+++ b/reftable/reftable.h\n@@ -0,0 +1,585 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#ifndef REFTABLE_H\n+#define REFTABLE_H\n+\n+#include <stdint.h>\n+#include <stddef.h>\n+\n+void reftable_set_alloc(void *(*malloc)(size_t),\n+\t\t\tvoid *(*realloc)(void *, size_t), void (*free)(void *));\n+\n+/****************************************************************\n+ Basic data types\n+\n+ Reftables store the state of each ref in struct reftable_ref_record, and they\n+ store a sequence of reflog updates in struct reftable_log_record.\n+ ****************************************************************/\n+\n+/* reftable_ref_record holds a ref database entry target_value */\n+struct reftable_ref_record {\n+\tchar *refname; /* Name of the ref, malloced. */\n+\tuint64_t update_index; /* Logical timestamp at which this value is\n+\t\t\t\t written */\n+\tuint8_t *value; /* SHA1, or NULL. malloced. */\n+\tuint8_t *target_value; /* peeled annotated tag, or NULL. malloced. */\n+\tchar *target; /* symref, or NULL. malloced. */\n+};\n+\n+/* returns whether 'ref' represents a deletion */\n+int reftable_ref_record_is_deletion(const struct reftable_ref_record *ref);\n+\n+/* prints a reftable_ref_record onto stdout */\n+void reftable_ref_record_print(struct reftable_ref_record *ref,\n+\t\t\t uint32_t hash_id);\n+\n+/* frees and nulls all pointer values. */\n+void reftable_ref_record_clear(struct reftable_ref_record *ref);\n+\n+/* returns whether two reftable_ref_records are the same */\n+int reftable_ref_record_equal(struct reftable_ref_record *a,\n+\t\t\t struct reftable_ref_record *b, int hash_size);\n+\n+/* reftable_log_record holds a reflog entry */\n+struct reftable_log_record {\n+\tchar *refname;\n+\tuint64_t update_index; /* logical timestamp of a transactional update.\n+\t\t\t\t*/\n+\tuint8_t *new_hash;\n+\tuint8_t *old_hash;\n+\tchar *name;\n+\tchar *email;\n+\tuint64_t time;\n+\tint16_t tz_offset;\n+\tchar *message;\n+};\n+\n+/* returns whether 'ref' represents the deletion of a log record. */\n+int reftable_log_record_is_deletion(const struct reftable_log_record *log);\n+\n+/* frees and nulls all pointer values. */\n+void reftable_log_record_clear(struct reftable_log_record *log);\n+\n+/* returns whether two records are equal. */\n+int reftable_log_record_equal(struct reftable_log_record *a,\n+\t\t\t struct reftable_log_record *b, int hash_size);\n+\n+/* dumps a reftable_log_record on stdout, for debugging/testing. */\n+void reftable_log_record_print(struct reftable_log_record *log,\n+\t\t\t uint32_t hash_id);\n+\n+/****************************************************************\n+ Error handling\n+\n+ Error are signaled with negative integer return values. 0 means success.\n+ ****************************************************************/\n+\n+/* different types of errors */\n+enum reftable_error {\n+\t/* Unexpected file system behavior */\n+\tREFTABLE_IO_ERROR = -2,\n+\n+\t/* Format inconsistency on reading data\n+\t */\n+\tREFTABLE_FORMAT_ERROR = -3,\n+\n+\t/* File does not exist. Returned from block_source_from_file(), because\n+\t it needs special handling in stack.\n+\t*/\n+\tREFTABLE_NOT_EXIST_ERROR = -4,\n+\n+\t/* Trying to write out-of-date data. */\n+\tREFTABLE_LOCK_ERROR = -5,\n+\n+\t/* Misuse of the API:\n+\t - on writing a record with NULL refname.\n+\t - on writing a reftable_ref_record outside the table limits\n+\t - on writing a ref or log record before the stack's next_update_index\n+\t - on writing a log record with multiline message with\n+\t exact_log_message unset\n+\t - on reading a reftable_ref_record from log iterator, or vice versa.\n+\t*/\n+\tREFTABLE_API_ERROR = -6,\n+\n+\t/* Decompression error */\n+\tREFTABLE_ZLIB_ERROR = -7,\n+\n+\t/* Wrote a table without blocks. */\n+\tREFTABLE_EMPTY_TABLE_ERROR = -8,\n+\n+\t/* Dir/file conflict. */\n+\tREFTABLE_NAME_CONFLICT = -9,\n+\n+\t/* Illegal ref name. */\n+\tREFTABLE_REFNAME_ERROR = -10,\n+};\n+\n+/* convert the numeric error code to a string. The string should not be\n+ * deallocated. */\n+const char *reftable_error_str(int err);\n+\n+/*\n+ * Convert the numeric error code to an equivalent errno code.\n+ */\n+int reftable_error_to_errno(int err);\n+\n+/****************************************************************\n+ Writing\n+\n+ Writing single reftables\n+ ****************************************************************/\n+\n+/* reftable_write_options sets options for writing a single reftable. */\n+struct reftable_write_options {\n+\t/* boolean: do not pad out blocks to block size. */\n+\n+\t/* the blocksize. Should be less than 2^24. */\n+\tuint32_t block_size;\n+\n+\t/* boolean: do not generate a SHA1 => ref index. */\n+\tint skip_index_objects;\n+\n+\t/* how often to write complete keys in each block. */\n+\tint restart_interval;\n+\n+\t/* 4-byte identifier (\"sha1\", \"s256\") of the hash.\n+\t * Defaults to SHA1 if unset\n+\t */\n+\tuint32_t hash_id;\n+\n+\t/* boolean: do not check ref names for validity or dir/file conflicts.\n+\t */\n+\tint skip_name_check;\n+\n+\t/* boolean: copy log messages exactly. If unset, check that the message\n+\t * is a single line, and add '\\n' if missing.\n+\t */\n+\tint exact_log_message;\n+};\n+\n+/* reftable_block_stats holds statistics for a single block type */\n+struct reftable_block_stats {\n+\t/* total number of entries written */\n+\tint entries;\n+\t/* total number of key restarts */\n+\tint restarts;\n+\t/* total number of blocks */\n+\tint blocks;\n+\t/* total number of index blocks */\n+\tint index_blocks;\n+\t/* depth of the index */\n+\tint max_index_level;\n+\n+\t/* offset of the first block for this type */\n+\tuint64_t offset;\n+\t/* offset of the top level index block for this type, or 0 if not\n+\t * present */\n+\tuint64_t index_offset;\n+};\n+\n+/* stats holds overall statistics for a single reftable */\n+struct reftable_stats {\n+\t/* total number of blocks written. */\n+\tint blocks;\n+\t/* stats for ref data */\n+\tstruct reftable_block_stats ref_stats;\n+\t/* stats for the SHA1 to ref map. */\n+\tstruct reftable_block_stats obj_stats;\n+\t/* stats for index blocks */\n+\tstruct reftable_block_stats idx_stats;\n+\t/* stats for log blocks */\n+\tstruct reftable_block_stats log_stats;\n+\n+\t/* disambiguation length of shortened object IDs. */\n+\tint object_id_len;\n+};\n+\n+/* reftable_new_writer creates a new writer */\n+struct reftable_writer *\n+reftable_new_writer(int (*writer_func)(void *, const void *, size_t),\n+\t\t void *writer_arg, struct reftable_write_options *opts);\n+\n+/* write to a file descriptor. fdp should be an int* pointing to the fd. */\n+int reftable_fd_write(void *fdp, const void *data, size_t size);\n+\n+/* Set the range of update indices for the records we will add. When\n+ writing a table into a stack, the min should be at least\n+ reftable_stack_next_update_index(), or REFTABLE_API_ERROR is returned.\n+\n+ For transactional updates, typically min==max. When converting an existing\n+ ref database into a single reftable, this would be a range of update-index\n+ timestamps.\n+ */\n+void reftable_writer_set_limits(struct reftable_writer *w, uint64_t min,\n+\t\t\t\tuint64_t max);\n+\n+/* adds a reftable_ref_record. Must be called in ascending\n+ order. The update_index must be within the limits set by\n+ reftable_writer_set_limits(), or REFTABLE_API_ERROR is returned.\n+\n+ It is an error to write a ref record after a log record.\n+ */\n+\t\t\t struct reftable_ref_record *ref);\n+\n+/* Convenience function to add multiple refs. Will sort the refs by\n+\t\t\t struct reftable_ref_record *refs, int n);\n+\n+/* adds a reftable_log_record. Must be called in ascending order (with more\n+ recent log entries first.)\n+ */\n+\t\t\t struct reftable_log_record *log);\n+\n+/* Convenience function to add multiple logs. Will sort the records by\n+\t\t\t struct reftable_log_record *logs, int n);\n+\n+/* reftable_writer_close finalizes the reftable. The writer is retained so\n+ * statistics can be inspected. */\n+int reftable_writer_close(struct reftable_writer *w);\n+\n+/* writer_stats returns the statistics on the reftable being written.\n+\n+ This struct becomes invalid when the writer is freed.\n+ */\n+const struct reftable_stats *writer_stats(struct reftable_writer *w);\n+\n+/* reftable_writer_free deallocates memory for the writer */\n+void reftable_writer_free(struct reftable_writer *w);\n+\n+/****************************************************************\n+ * ITERATING\n+ ****************************************************************/\n+\n+/* iterator is the generic interface for walking over data stored in a\n+ reftable. It is generally passed around by value.\n+*/\n+struct reftable_iterator {\n+\tstruct reftable_iterator_vtable *ops;\n+\tvoid *iter_arg;\n+};\n+\n+/* reads the next reftable_ref_record. Returns < 0 for error, 0 for OK and > 0:\n+ end of iteration.\n+*/\n+int reftable_iterator_next_ref(struct reftable_iterator *it,\n+\t\t\t struct reftable_ref_record *ref);\n+\n+/* reads the next reftable_log_record. Returns < 0 for error, 0 for OK and > 0:\n+ end of iteration.\n+*/\n+int reftable_iterator_next_log(struct reftable_iterator *it,\n+\t\t\t struct reftable_log_record *log);\n+\n+/* releases resources associated with an iterator. */\n+void reftable_iterator_destroy(struct reftable_iterator *it);\n+\n+/****************************************************************\n+\n+ The follow routines are for reading single files. For an application-level\n+ interface, skip ahead to struct reftable_merged_table and struct\n+ reftable_stack.\n+ ****************************************************************/\n+\n+/* block_source is a generic wrapper for a seekable readable file.\n+ It is generally passed around by value.\n+ */\n+struct reftable_block_source {\n+\tstruct reftable_block_source_vtable *ops;\n+\tvoid *arg;\n+};\n+\n+/* a contiguous segment of bytes. It keeps track of its generating block_source\n+ so it can return itself into the pool.\n+*/\n+struct reftable_block {\n+\tuint8_t *data;\n+\tint len;\n+\tstruct reftable_block_source source;\n+};\n+\n+/* block_source_vtable are the operations that make up block_source */\n+struct reftable_block_source_vtable {\n+\t/* returns the size of a block source */\n+\tuint64_t (*size)(void *source);\n+\n+\t/* reads a segment from the block source. It is an error to read\n+\t beyond the end of the block */\n+\tint (*read_block)(void *source, struct reftable_block *dest,\n+\t\t\t uint64_t off, uint32_t size);\n+\t/* mark the block as read; may return the data back to malloc */\n+\tvoid (*return_block)(void *source, struct reftable_block *blockp);\n+\n+\t/* release all resources associated with the block source */\n+\tvoid (*close)(void *source);\n+};\n+\n+/* opens a file on the file system as a block_source */\n+int reftable_block_source_from_file(struct reftable_block_source *block_src,\n+\t\t\t\t const char *name);\n+\n+/* The reader struct is a handle to an open reftable file. */\n+\n+ * code and sets pp. The name is used for creating a stack. Typically, it is the\n+ * basename of the file. The block source `src` is owned by the reader, and is\n+ * closed on calling reftable_reader_destroy().\n+ */\n+\t\t\tstruct reftable_block_source *src, const char *name);\n+\n+/* reftable_reader_seek_ref returns an iterator where 'name' would be inserted\n+ in the table. To seek to the start of the table, use name = \"\".\n+\n+ example:\n+\n+ struct reftable_reader *r = NULL;\n+ int err = reftable_new_reader(&r, &src, \"filename\");\n+ if (err < 0) { ... }\n+ struct reftable_iterator it = {0};\n+ if (err < 0) { ... }\n+ struct reftable_ref_record ref = {0};\n+ while (1) {\n+ err = reftable_iterator_next_ref(&it, &ref);\n+ if (err > 0) {\n+ break;\n+ }\n+ if (err < 0) {\n+ ..error handling..\n+ }\n+ ..found..\n+ }\n+ reftable_iterator_destroy(&it);\n+ reftable_ref_record_clear(&ref);\n+ */\n+\t\t\t struct reftable_iterator *it, const char *name);\n+\n+/* returns the hash ID used in this table. */\n+\n+/* seek to logs for the given name, older than update_index. To seek to the\n+ start of the table, use name = \"\".\n+ */\n+\t\t\t\tstruct reftable_iterator *it, const char *name,\n+\t\t\t\tuint64_t update_index);\n+\n+/* seek to newest log entry for given name. */\n+\t\t\t struct reftable_iterator *it, const char *name);\n+\n+/* closes and deallocates a reader. */\n+\n+/* return an iterator for the refs pointing to `oid`. */\n+\t\t\t struct reftable_iterator *it, uint8_t *oid);\n+\n+/* return the max_update_index for a table */\n+\n+/* return the min_update_index for a table */\n+\n+/****************************************************************\n+ Merged tables\n+\n+ A ref database kept in a sequence of table files. The merged_table presents a\n+ unified view to reading (seeking, iterating) a sequence of immutable tables.\n+ ****************************************************************/\n+\n+/* A merged table is implements seeking/iterating over a stack of tables. */\n+struct reftable_merged_table;\n+\n+/* A generic reftable; see below. */\n+struct reftable_table;\n+\n+/* reftable_new_merged_table creates a new merged table. It takes ownership of\n+ the stack array.\n+*/\n+int reftable_new_merged_table(struct reftable_merged_table **dest,\n+\t\t\t struct reftable_table *stack, int n,\n+\t\t\t uint32_t hash_id);\n+\n+/* returns an iterator positioned just before 'name' */\n+int reftable_merged_table_seek_ref(struct reftable_merged_table *mt,\n+\t\t\t\t struct reftable_iterator *it,\n+\t\t\t\t const char *name);\n+\n+/* returns an iterator for log entry, at given update_index */\n+int reftable_merged_table_seek_log_at(struct reftable_merged_table *mt,\n+\t\t\t\t struct reftable_iterator *it,\n+\t\t\t\t const char *name, uint64_t update_index);\n+\n+/* like reftable_merged_table_seek_log_at but look for the newest entry. */\n+int reftable_merged_table_seek_log(struct reftable_merged_table *mt,\n+\t\t\t\t struct reftable_iterator *it,\n+\t\t\t\t const char *name);\n+\n+/* returns the max update_index covered by this merged table. */\n+uint64_t\n+reftable_merged_table_max_update_index(struct reftable_merged_table *mt);\n+\n+/* returns the min update_index covered by this merged table. */\n+uint64_t\n+reftable_merged_table_min_update_index(struct reftable_merged_table *mt);\n+\n+/* releases memory for the merged_table */\n+void reftable_merged_table_free(struct reftable_merged_table *m);\n+\n+/* return the hash ID of the merged table. */\n+uint32_t reftable_merged_table_hash_id(struct reftable_merged_table *m);\n+\n+/****************************************************************\n+ Generic tables\n+\n+ A unified API for reading tables, either merged tables, or single readers.\n+ ****************************************************************/\n+\n+struct reftable_table {\n+\tstruct reftable_table_vtable *ops;\n+\tvoid *table_arg;\n+};\n+\n+int reftable_table_seek_ref(struct reftable_table *tab,\n+\t\t\t struct reftable_iterator *it, const char *name);\n+\n+\n+/* returns the hash ID from a generic reftable_table */\n+uint32_t reftable_table_hash_id(struct reftable_table *tab);\n+\n+/* create a generic table from reftable_merged_table */\n+void reftable_table_from_merged_table(struct reftable_table *tab,\n+\t\t\t\t struct reftable_merged_table *table);\n+\n+/* returns the max update_index covered by this table. */\n+uint64_t reftable_table_max_update_index(struct reftable_table *tab);\n+\n+/* returns the min update_index covered by this table. */\n+uint64_t reftable_table_min_update_index(struct reftable_table *tab);\n+\n+/* convenience function to read a single ref. Returns < 0 for error, 0\n+int reftable_table_read_ref(struct reftable_table *tab, const char *name,\n+\t\t\t struct reftable_ref_record *ref);\n+\n+/****************************************************************\n+ Mutable ref database\n+\n+ The stack presents an interface to a mutable sequence of reftables.\n+ ****************************************************************/\n+\n+/* a stack is a stack of reftables, which can be mutated by pushing a table to\n+ * the top of the stack */\n+struct reftable_stack;\n+\n+/* open a new reftable stack. The tables along with the table list will be\n+ stored in 'dir'. Typically, this should be .git/reftables.\n+*/\n+int reftable_new_stack(struct reftable_stack **dest, const char *dir,\n+\t\t struct reftable_write_options config);\n+\n+/* returns the update_index at which a next table should be written. */\n+uint64_t reftable_stack_next_update_index(struct reftable_stack *st);\n+\n+/* holds a transaction to add tables at the top of a stack. */\n+\n+/*\n+ returns a new transaction to add reftables to the given stack. As a side\n+ effect, the ref database is locked.\n+*/\n+\t\t\t\tstruct reftable_stack *st);\n+\n+/* Adds a reftable to transaction. */\n+\t\t\t int (*write_table)(struct reftable_writer *wr,\n+\t\t\t\t\t void *arg),\n+\t\t\t void *arg);\n+\n+/* Commits the transaction, releasing the lock. */\n+\n+/* Release all non-committed data from the transaction, and deallocate the\n+ transaction. Releases the lock if held. */\n+\n+/* add a new table to the stack. The write_table function must call\n+ reftable_writer_set_limits, add refs and return an error value. */\n+\t\t int (*write_table)(struct reftable_writer *wr,\n+\t\t\t\t\t void *write_arg),\n+\t\t void *write_arg);\n+\n+/* returns the merged_table for seeking. This table is valid until the\n+ next write or reload, and should not be closed or deleted.\n+*/\n+struct reftable_merged_table *\n+reftable_stack_merged_table(struct reftable_stack *st);\n+\n+/* frees all resources associated with the stack. */\n+void reftable_stack_destroy(struct reftable_stack *st);\n+\n+/* Reloads the stack if necessary. This is very cheap to run if the stack was up\n+ * to date */\n+\n+/* Policy for expiring reflog entries. */\n+struct reftable_log_expiry_config {\n+\t/* Drop entries older than this timestamp */\n+\tuint64_t time;\n+\n+\t/* Drop older entries */\n+\tuint64_t min_update_index;\n+};\n+\n+/* compacts all reftables into a giant table. Expire reflog entries if config is\n+ * non-NULL */\n+int reftable_stack_compact_all(struct reftable_stack *st,\n+\t\t\t struct reftable_log_expiry_config *config);\n+\n+/* heuristically compact unbalanced table stack. */\n+int reftable_stack_auto_compact(struct reftable_stack *st);\n+\n+/* convenience function to read a single ref. Returns < 0 for error, 0\n+int reftable_stack_read_ref(struct reftable_stack *st, const char *refname,\n+\t\t\t struct reftable_ref_record *ref);\n+\n+/* convenience function to read a single log. Returns < 0 for error, 0\n+int reftable_stack_read_log(struct reftable_stack *st, const char *refname,\n+\t\t\t struct reftable_log_record *log);\n+\n+/* statistics on past compactions. */\n+struct reftable_compaction_stats {\n+\tuint64_t bytes; /* total number of bytes written */\n+\tuint64_t entries_written; /* total number of entries written, including\n+\t\t\t\t failures. */\n+\tint attempts; /* how often we tried to compact */\n+\tint failures; /* failures happen on concurrent updates */\n+};\n+\n+/* return statistics for compaction up till now. */\n+struct reftable_compaction_stats *\n+reftable_stack_compaction_stats(struct reftable_stack *st);\n+\n+#endif\n--\n\n• ```* [PATCH 03/13] vcxproj: adjust for the reftable changes\n2020-09-16 19:10 [PATCH 00/13] reftable library Han-Wen Nienhuys via GitGitGadget\n2020-09-16 19:10 ` [PATCH 02/13] reftable: define the public API Han-Wen Nienhuys via GitGitGadget\n@ 2020-09-16 19:10 ` Johannes Schindelin via GitGitGadget\n2020-09-16 19:10 ` [PATCH 04/13] reftable: add a barebones unittest framework Han-Wen Nienhuys via GitGitGadget\n` (10 subsequent siblings)\n13 siblings, 0 replies; 251+ messages in thread\nFrom: Johannes Schindelin via GitGitGadget @ 2020-09-16 19:10 UTC (permalink / raw)\nTo: git; +Cc: Han-Wen Nienhuys, Johannes Schindelin\n\nFrom: Johannes Schindelin <[email protected]>\n\nThis allows Git to be compiled via Visual Studio again after integrating\nthe `hn/reftable` branch.\n\nSigned-off-by: Johannes Schindelin <[email protected]>\n---\nconfig.mak.uname | 2 +-\ncontrib/buildsystems/Generators/Vcxproj.pm | 11 ++++++++++-\n2 files changed, 11 insertions(+), 2 deletions(-)\n\ndiff --git a/config.mak.uname b/config.mak.uname\nindex c7eba69e54..ae4e25a1a4 100644\n--- a/config.mak.uname\n+++ b/config.mak.uname\n@@ -709,7 +709,7 @@ vcxproj:\n# Make .vcxproj files and add them\nunset QUIET_GEN QUIET_BUILT_IN; \\\nperl contrib/buildsystems/generate -g Vcxproj\n-\tgit add -f git.sln {*,*/lib,t/helper/*}/*.vcxproj\n+\tgit add -f git.sln {*,*/lib,*/libreftable,t/helper/*}/*.vcxproj\n\n(echo '<Project xmlns=\"http://schemas.microsoft.com/developer/msbuild/2003\">' && \\\ndiff --git a/contrib/buildsystems/Generators/Vcxproj.pm b/contrib/buildsystems/Generators/Vcxproj.pm\nindex d2584450ba..1a25789d28 100644\n--- a/contrib/buildsystems/Generators/Vcxproj.pm\n+++ b/contrib/buildsystems/Generators/Vcxproj.pm\n@@ -77,7 +77,7 @@ sub createProject {\nmy \\$libs_release = \"\\n \";\nmy \\$libs_debug = \"\\n \";\nif (!\\$static_library) {\n- \\$libs_release = join(\";\", sort(grep /^(?!libgit\\.lib|xdiff\\/lib\\.lib|vcs-svn\\/lib\\.lib)/, @{\\$\\$build_structure{\"\\$prefix\\${name}_LIBS\"}}));\n+ \\$libs_release = join(\";\", sort(grep /^(?!libgit\\.lib|xdiff\\/lib\\.lib|vcs-svn\\/lib\\.lib|reftable\\/libreftable\\.lib)/, @{\\$\\$build_structure{\"\\$prefix\\${name}_LIBS\"}}));\n\\$libs_debug = \\$libs_release;\n\\$libs_debug =~ s/zlib\\.lib/zlibd\\.lib/g;\n\\$libs_debug =~ s/libexpat\\.lib/libexpatd\\.lib/g;\n@@ -232,6 +232,7 @@ sub createProject {\nEOM\nif (!\\$static_library || \\$target =~ 'vcs-svn' || \\$target =~ 'xdiff') {\nmy \\$uuid_libgit = \\$\\$build_structure{\"LIBS_libgit_GUID\"};\n+ my \\$uuid_libreftable = \\$\\$build_structure{\"LIBS_reftable/libreftable_GUID\"};\nmy \\$uuid_xdiff_lib = \\$\\$build_structure{\"LIBS_xdiff/lib_GUID\"};\n\nprint F << \"EOM\";\n@@ -241,6 +242,14 @@ sub createProject {\n<ReferenceOutputAssembly>false</ReferenceOutputAssembly>\n</ProjectReference>\nEOM\n+ if (!(\\$name =~ /xdiff|libreftable/)) {\n+ print F << \"EOM\";\n+ <ProjectReference Include=\"\\$cdup\\\\reftable\\\\libreftable\\\\libreftable.vcxproj\">\n+ <Project>\\$uuid_libreftable</Project>\n+ <ReferenceOutputAssembly>false</ReferenceOutputAssembly>\n+ </ProjectReference>\n+EOM\n+ }\nif (!(\\$name =~ 'xdiff')) {\nprint F << \"EOM\";\n<ProjectReference Include=\"\\$cdup\\\\xdiff\\\\lib\\\\xdiff_lib.vcxproj\">\n--\n\n• ```* [PATCH 04/13] reftable: add a barebones unittest framework\n2020-09-16 19:10 [PATCH 00/13] reftable library Han-Wen Nienhuys via GitGitGadget\n` (2 preceding siblings ...)\n2020-09-16 19:10 ` [PATCH 03/13] vcxproj: adjust for the reftable changes Johannes Schindelin via GitGitGadget\n@ 2020-09-16 19:10 ` Han-Wen Nienhuys via GitGitGadget\n2020-09-16 19:10 ` [PATCH 05/13] reftable: utility functions Han-Wen Nienhuys via GitGitGadget\n` (9 subsequent siblings)\n13 siblings, 0 replies; 251+ messages in thread\nFrom: Han-Wen Nienhuys via GitGitGadget @ 2020-09-16 19:10 UTC (permalink / raw)\nTo: git; +Cc: Han-Wen Nienhuys, Han-Wen Nienhuys\n\n---\nreftable/test_framework.c | 68 +++++++++++++++++++++++++++++++++++++++\nreftable/test_framework.h | 60 ++++++++++++++++++++++++++++++++++\n2 files changed, 128 insertions(+)\ncreate mode 100644 reftable/test_framework.c\ncreate mode 100644 reftable/test_framework.h\n\ndiff --git a/reftable/test_framework.c b/reftable/test_framework.c\nnew file mode 100644\nindex 0000000000..f304a2773a\n--- /dev/null\n+++ b/reftable/test_framework.c\n@@ -0,0 +1,68 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"test_framework.h\"\n+\n+#include \"system.h\"\n+#include \"basics.h\"\n+\n+struct test_case **test_cases;\n+int test_case_len;\n+int test_case_cap;\n+\n+struct test_case *new_test_case(const char *name, void (*testfunc)(void))\n+{\n+\tstruct test_case *tc = reftable_malloc(sizeof(struct test_case));\n+\ttc->name = name;\n+\ttc->testfunc = testfunc;\n+\treturn tc;\n+}\n+\n+struct test_case *add_test_case(const char *name, void (*testfunc)(void))\n+{\n+\tstruct test_case *tc = new_test_case(name, testfunc);\n+\tif (test_case_len == test_case_cap) {\n+\t\ttest_case_cap = 2 * test_case_cap + 1;\n+\t\ttest_cases = reftable_realloc(\n+\t\t\ttest_cases, sizeof(struct test_case) * test_case_cap);\n+\t}\n+\n+\ttest_cases[test_case_len++] = tc;\n+\treturn tc;\n+}\n+\n+int test_main(int argc, const char *argv[])\n+{\n+\tconst char *filter = NULL;\n+\tint i = 0;\n+\tif (argc > 1) {\n+\t\tfilter = argv;\n+\t}\n+\n+\tfor (i = 0; i < test_case_len; i++) {\n+\t\tconst char *name = test_cases[i]->name;\n+\t\tif (filter == NULL || strstr(name, filter) != NULL) {\n+\t\t\tprintf(\"case %s\\n\", name);\n+\t\t\ttest_cases[i]->testfunc();\n+\t\t} else {\n+\t\t\tprintf(\"skip %s\\n\", name);\n+\t\t}\n+\n+\t\treftable_free(test_cases[i]);\n+\t}\n+\treftable_free(test_cases);\n+\ttest_cases = 0;\n+\ttest_case_len = 0;\n+\ttest_case_cap = 0;\n+\treturn 0;\n+}\n+\n+void set_test_hash(uint8_t *p, int i)\n+{\n+\tmemset(p, (uint8_t)i, hash_size(SHA1_ID));\n+}\ndiff --git a/reftable/test_framework.h b/reftable/test_framework.h\nnew file mode 100644\nindex 0000000000..3c74d287aa\n--- /dev/null\n+++ b/reftable/test_framework.h\n@@ -0,0 +1,60 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#ifndef TEST_FRAMEWORK_H\n+#define TEST_FRAMEWORK_H\n+\n+#include \"system.h\"\n+\n+#ifdef NDEBUG\n+#undef NDEBUG\n+#endif\n+\n+#ifdef assert\n+#undef assert\n+#endif\n+\n+#define assert_err(c) \\\n+\tif (c != 0) { \\\n+\t\tfflush(stderr); \\\n+\t\tfflush(stdout); \\\n+\t\tfprintf(stderr, \"%s: %d: error == %d (%s), want 0\\n\", \\\n+\t\t\t__FILE__, __LINE__, c, reftable_error_str(c)); \\\n+\t\tabort(); \\\n+\t}\n+\n+#define assert_streq(a, b) \\\n+\tif (strcmp(a, b)) { \\\n+\t\tfflush(stderr); \\\n+\t\tfflush(stdout); \\\n+\t\tfprintf(stderr, \"%s:%d: %s (%s) != %s (%s)\\n\", __FILE__, \\\n+\t\t\t__LINE__, #a, a, #b, b); \\\n+\t\tabort(); \\\n+\t}\n+\n+#define assert(c) \\\n+\tif (!(c)) { \\\n+\t\tfflush(stderr); \\\n+\t\tfflush(stdout); \\\n+\t\tfprintf(stderr, \"%s: %d: failed assertion %s\\n\", __FILE__, \\\n+\t\t\t__LINE__, #c); \\\n+\t\tabort(); \\\n+\t}\n+\n+struct test_case {\n+\tconst char *name;\n+\tvoid (*testfunc)(void);\n+};\n+\n+struct test_case *new_test_case(const char *name, void (*testfunc)(void));\n+struct test_case *add_test_case(const char *name, void (*testfunc)(void));\n+int test_main(int argc, const char *argv[]);\n+\n+void set_test_hash(uint8_t *p, int i);\n+\n+#endif\n--\n\n• ```* [PATCH 05/13] reftable: utility functions\n2020-09-16 19:10 [PATCH 00/13] reftable library Han-Wen Nienhuys via GitGitGadget\n` (3 preceding siblings ...)\n2020-09-16 19:10 ` [PATCH 04/13] reftable: add a barebones unittest framework Han-Wen Nienhuys via GitGitGadget\n@ 2020-09-16 19:10 ` Han-Wen Nienhuys via GitGitGadget\n2020-09-16 19:10 ` [PATCH 06/13] reftable: (de)serialization for the polymorphic record type Han-Wen Nienhuys via GitGitGadget\n` (8 subsequent siblings)\n13 siblings, 0 replies; 251+ messages in thread\nFrom: Han-Wen Nienhuys via GitGitGadget @ 2020-09-16 19:10 UTC (permalink / raw)\nTo: git; +Cc: Han-Wen Nienhuys, Han-Wen Nienhuys\n\nThis commit provides basic utility classes for the reftable library.\n\nSince the reftable library must compile standalone, there may be some overlap\nwith git-core utility functions.\n\n---\nMakefile | 26 ++++++-\nreftable/basics.c | 131 +++++++++++++++++++++++++++++++++\nreftable/basics.h | 48 +++++++++++++\nreftable/blocksource.c | 148 ++++++++++++++++++++++++++++++++++++++\nreftable/blocksource.h | 22 ++++++\nreftable/compat.c | 110 ++++++++++++++++++++++++++++\nreftable/compat.h | 48 +++++++++++++\nreftable/publicbasics.c | 100 ++++++++++++++++++++++++++\nreftable/reftable-tests.h | 22 ++++++\nreftable/strbuf.c | 142 ++++++++++++++++++++++++++++++++++++\nreftable/strbuf.h | 80 +++++++++++++++++++++\nreftable/strbuf_test.c | 37 ++++++++++\nreftable/system.h | 51 +++++++++++++\nt/helper/test-reftable.c | 8 +++\nt/helper/test-tool.c | 1 +\nt/helper/test-tool.h | 1 +\n16 files changed, 972 insertions(+), 3 deletions(-)\ncreate mode 100644 reftable/basics.c\ncreate mode 100644 reftable/basics.h\ncreate mode 100644 reftable/blocksource.c\ncreate mode 100644 reftable/blocksource.h\ncreate mode 100644 reftable/compat.c\ncreate mode 100644 reftable/compat.h\ncreate mode 100644 reftable/publicbasics.c\ncreate mode 100644 reftable/reftable-tests.h\ncreate mode 100644 reftable/strbuf.c\ncreate mode 100644 reftable/strbuf.h\ncreate mode 100644 reftable/strbuf_test.c\ncreate mode 100644 reftable/system.h\ncreate mode 100644 t/helper/test-reftable.c\n\ndiff --git a/Makefile b/Makefile\nindex 86e5411f39..66158525a9 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -720,6 +720,7 @@ TEST_BUILTINS_OBJS += test-read-cache.o\nTEST_BUILTINS_OBJS += test-ref-store.o\n+TEST_BUILTINS_OBJS += test-reftable.o\nTEST_BUILTINS_OBJS += test-regex.o\nTEST_BUILTINS_OBJS += test-repository.o\nTEST_BUILTINS_OBJS += test-revision-walking.o\n@@ -799,6 +800,8 @@ TEST_SHELL_PATH = \\$(SHELL_PATH)\n\nLIB_FILE = libgit.a\nXDIFF_LIB = xdiff/lib.a\n+REFTABLE_LIB = reftable/libreftable.a\n+REFTABLE_TEST_LIB = reftable/libreftable_test.a\n\nGENERATED_H += config-list.h\nGENERATED_H += command-list.h\n@@ -1160,7 +1163,7 @@ THIRD_PARTY_SOURCES += compat/regex/%\nTHIRD_PARTY_SOURCES += sha1collisiondetection/%\nTHIRD_PARTY_SOURCES += sha1dc/%\n\n-GITLIBS = common-main.o \\$(LIB_FILE) \\$(XDIFF_LIB)\n+GITLIBS = common-main.o \\$(LIB_FILE) \\$(XDIFF_LIB) \\$(REFTABLE_LIB)\nEXTLIBS =\n\nGIT_USER_AGENT = git/\\$(GIT_VERSION)\n@@ -2341,10 +2344,21 @@ XDIFF_OBJS += xdiff/xpatience.o\nXDIFF_OBJS += xdiff/xprepare.o\nXDIFF_OBJS += xdiff/xutils.o\n\n+REFTABLE_OBJS += reftable/basics.o\n+REFTABLE_OBJS += reftable/blocksource.o\n+REFTABLE_OBJS += reftable/publicbasics.o\n+REFTABLE_OBJS += reftable/compat.o\n+REFTABLE_OBJS += reftable/strbuf.o\n+\n+REFTABLE_TEST_OBJS += reftable/strbuf_test.o\n+REFTABLE_TEST_OBJS += reftable/test_framework.o\n+\nTEST_OBJS := \\$(patsubst %\\$X,%.o,\\$(TEST_PROGRAMS)) \\$(patsubst %,t/helper/%,\\$(TEST_BUILTINS_OBJS))\nOBJECTS := \\$(LIB_OBJS) \\$(BUILTIN_OBJS) \\$(PROGRAM_OBJS) \\$(TEST_OBJS) \\\n\\$(XDIFF_OBJS) \\\n\\$(FUZZ_OBJS) \\\n+\t\\$(REFTABLE_OBJS) \\\n+\t\\$(REFTABLE_TEST_OBJS) \\\ncommon-main.o \\\ngit.o\nifndef NO_CURL\n@@ -2474,6 +2488,12 @@ \\$(LIB_FILE): \\$(LIB_OBJS)\n\\$(XDIFF_LIB): \\$(XDIFF_OBJS)\n\\$(QUIET_AR)\\$(RM) \\$@ && \\$(AR) \\$(ARFLAGS) \\$@ \\$^\n\n+\\$(REFTABLE_LIB): \\$(REFTABLE_OBJS)\n+\t\\$(QUIET_AR)\\$(RM) \\$@ && \\$(AR) \\$(ARFLAGS) \\$@ \\$^\n+\n+\\$(REFTABLE_TEST_LIB): \\$(REFTABLE_TEST_OBJS)\n+\t\\$(QUIET_AR)\\$(RM) \\$@ && \\$(AR) \\$(ARFLAGS) \\$@ \\$^\n+\nexport DEFAULT_EDITOR DEFAULT_PAGER\n\nDocumentation/GIT-EXCLUDED-PROGRAMS: FORCE\n@@ -2752,7 +2772,7 @@ perf: all\n\nt/helper/test-tool\\$X: \\$(patsubst %,t/helper/%,\\$(TEST_BUILTINS_OBJS))\n\n-t/helper/test-%\\$X: t/helper/test-%.o GIT-LDFLAGS \\$(GITLIBS)\n+t/helper/test-%\\$X: t/helper/test-%.o GIT-LDFLAGS \\$(GITLIBS) \\$(REFTABLE_TEST_LIB)\n\\$(QUIET_LINK)\\$(CC) \\$(ALL_CFLAGS) -o \\$@ \\$(ALL_LDFLAGS) \\$(filter %.o,\\$^) \\$(filter %.a,\\$^) \\$(LIBS)\n\ncheck-sha1:: t/helper/test-tool\\$X\n@@ -3080,7 +3100,7 @@ cocciclean:\nclean: profile-clean coverage-clean cocciclean\n\\$(RM) *.res\n\\$(RM) \\$(OBJECTS)\n-\t\\$(RM) \\$(LIB_FILE) \\$(XDIFF_LIB)\n+\t\\$(RM) \\$(LIB_FILE) \\$(XDIFF_LIB) \\$(REFTABLE_LIB) \\$(REFTABLE_TEST_LIB)\n\\$(RM) \\$(ALL_PROGRAMS) \\$(SCRIPT_LIB) \\$(BUILT_INS) git\\$X\n\\$(RM) \\$(TEST_PROGRAMS)\n\\$(RM) \\$(FUZZ_PROGRAMS)\ndiff --git a/reftable/basics.c b/reftable/basics.c\nnew file mode 100644\nindex 0000000000..c429055d15\n--- /dev/null\n+++ b/reftable/basics.c\n@@ -0,0 +1,131 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"basics.h\"\n+\n+void put_be24(uint8_t *out, uint32_t i)\n+{\n+\tout = (uint8_t)((i >> 16) & 0xff);\n+\tout = (uint8_t)((i >> 8) & 0xff);\n+\tout = (uint8_t)(i & 0xff);\n+}\n+\n+uint32_t get_be24(uint8_t *in)\n+{\n+\treturn (uint32_t)(in) << 16 | (uint32_t)(in) << 8 |\n+\t (uint32_t)(in);\n+}\n+\n+void put_be16(uint8_t *out, uint16_t i)\n+{\n+\tout = (uint8_t)((i >> 8) & 0xff);\n+\tout = (uint8_t)(i & 0xff);\n+}\n+\n+int binsearch(size_t sz, int (*f)(size_t k, void *args), void *args)\n+{\n+\tsize_t lo = 0;\n+\tsize_t hi = sz;\n+\n+\t/* invariant: (hi == sz) || f(hi) == true\n+\t (lo == 0 && f(0) == true) || fi(lo) == false\n+\t */\n+\twhile (hi - lo > 1) {\n+\t\tsize_t mid = lo + (hi - lo) / 2;\n+\n+\t\tint val = f(mid, args);\n+\t\tif (val) {\n+\t\t\thi = mid;\n+\t\t} else {\n+\t\t\tlo = mid;\n+\t\t}\n+\t}\n+\n+\tif (lo == 0) {\n+\t\tif (f(0, args)) {\n+\t\t\treturn 0;\n+\t\t} else {\n+\t\t\treturn 1;\n+\t\t}\n+\t}\n+\n+\treturn hi;\n+}\n+\n+void free_names(char **a)\n+{\n+\tchar **p = a;\n+\tif (p == NULL) {\n+\t\treturn;\n+\t}\n+\twhile (*p) {\n+\t\treftable_free(*p);\n+\t\tp++;\n+\t}\n+\treftable_free(a);\n+}\n+\n+int names_length(char **names)\n+{\n+\tint len = 0;\n+\tchar **p = names;\n+\twhile (*p) {\n+\t\tp++;\n+\t\tlen++;\n+\t}\n+\treturn len;\n+}\n+\n+void parse_names(char *buf, int size, char ***namesp)\n+{\n+\tchar **names = NULL;\n+\tsize_t names_cap = 0;\n+\tsize_t names_len = 0;\n+\n+\tchar *p = buf;\n+\tchar *end = buf + size;\n+\twhile (p < end) {\n+\t\tchar *next = strchr(p, '\\n');\n+\t\tif (next != NULL) {\n+\t\t\t*next = 0;\n+\t\t} else {\n+\t\t\tnext = end;\n+\t\t}\n+\t\tif (p < next) {\n+\t\t\tif (names_len == names_cap) {\n+\t\t\t\tnames_cap = 2 * names_cap + 1;\n+\t\t\t\tnames = reftable_realloc(\n+\t\t\t\t\tnames, names_cap * sizeof(char *));\n+\t\t\t}\n+\t\t\tnames[names_len++] = xstrdup(p);\n+\t\t}\n+\t\tp = next + 1;\n+\t}\n+\n+\tif (names_len == names_cap) {\n+\t\tnames_cap = 2 * names_cap + 1;\n+\t\tnames = reftable_realloc(names, names_cap * sizeof(char *));\n+\t}\n+\n+\tnames[names_len] = NULL;\n+\t*namesp = names;\n+}\n+\n+int names_equal(char **a, char **b)\n+{\n+\twhile (*a && *b) {\n+\t\tif (strcmp(*a, *b)) {\n+\t\t\treturn 0;\n+\t\t}\n+\n+\t\ta++;\n+\t\tb++;\n+\t}\n+\n+\treturn *a == *b;\n+}\ndiff --git a/reftable/basics.h b/reftable/basics.h\nnew file mode 100644\nindex 0000000000..90639865a7\n--- /dev/null\n+++ b/reftable/basics.h\n@@ -0,0 +1,48 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#ifndef BASICS_H\n+#define BASICS_H\n+\n+#include \"system.h\"\n+\n+/* Bigendian en/decoding of integers */\n+\n+void put_be24(uint8_t *out, uint32_t i);\n+uint32_t get_be24(uint8_t *in);\n+void put_be16(uint8_t *out, uint16_t i);\n+\n+/*\n+ find smallest index i in [0, sz) at which f(i) is true, assuming\n+ that f is ascending. Return sz if f(i) is false for all indices.\n+*/\n+int binsearch(size_t sz, int (*f)(size_t k, void *args), void *args);\n+\n+/*\n+ Frees a NULL terminated array of malloced strings. The array itself is also\n+ freed.\n+ */\n+void free_names(char **a);\n+\n+/* parse a newline separated list of names. Empty names are discarded. */\n+void parse_names(char *buf, int size, char ***namesp);\n+\n+/* compares two NULL-terminated arrays of strings. */\n+int names_equal(char **a, char **b);\n+\n+/* returns the array size of a NULL-terminated array of strings. */\n+int names_length(char **names);\n+\n+/* Allocation routines; they invoke the functions set through\n+ * reftable_set_alloc() */\n+void *reftable_malloc(size_t sz);\n+void *reftable_realloc(void *p, size_t sz);\n+void reftable_free(void *p);\n+void *reftable_calloc(size_t sz);\n+\n+#endif\ndiff --git a/reftable/blocksource.c b/reftable/blocksource.c\nnew file mode 100644\nindex 0000000000..f12cea2472\n--- /dev/null\n+++ b/reftable/blocksource.c\n@@ -0,0 +1,148 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"system.h\"\n+\n+#include \"basics.h\"\n+#include \"blocksource.h\"\n+#include \"strbuf.h\"\n+#include \"reftable.h\"\n+\n+static void strbuf_return_block(void *b, struct reftable_block *dest)\n+{\n+\tmemset(dest->data, 0xff, dest->len);\n+\treftable_free(dest->data);\n+}\n+\n+static void strbuf_close(void *b)\n+{\n+}\n+\n+static int strbuf_read_block(void *v, struct reftable_block *dest, uint64_t off,\n+\t\t\t uint32_t size)\n+{\n+\tstruct strbuf *b = (struct strbuf *)v;\n+\tassert(off + size <= b->len);\n+\tdest->data = reftable_calloc(size);\n+\tmemcpy(dest->data, b->buf + off, size);\n+\tdest->len = size;\n+\treturn size;\n+}\n+\n+static uint64_t strbuf_size(void *b)\n+{\n+\treturn ((struct strbuf *)b)->len;\n+}\n+\n+struct reftable_block_source_vtable strbuf_vtable = {\n+\t.size = &strbuf_size,\n+\t.return_block = &strbuf_return_block,\n+\t.close = &strbuf_close,\n+};\n+\n+void block_source_from_strbuf(struct reftable_block_source *bs,\n+\t\t\t struct strbuf *buf)\n+{\n+\tassert(bs->ops == NULL);\n+\tbs->ops = &strbuf_vtable;\n+\tbs->arg = buf;\n+}\n+\n+static void malloc_return_block(void *b, struct reftable_block *dest)\n+{\n+\tmemset(dest->data, 0xff, dest->len);\n+\treftable_free(dest->data);\n+}\n+\n+struct reftable_block_source_vtable malloc_vtable = {\n+\t.return_block = &malloc_return_block,\n+};\n+\n+struct reftable_block_source malloc_block_source_instance = {\n+\t.ops = &malloc_vtable,\n+};\n+\n+struct reftable_block_source malloc_block_source(void)\n+{\n+\treturn malloc_block_source_instance;\n+}\n+\n+struct file_block_source {\n+\tint fd;\n+\tuint64_t size;\n+};\n+\n+static uint64_t file_size(void *b)\n+{\n+\treturn ((struct file_block_source *)b)->size;\n+}\n+\n+static void file_return_block(void *b, struct reftable_block *dest)\n+{\n+\tmemset(dest->data, 0xff, dest->len);\n+\treftable_free(dest->data);\n+}\n+\n+static void file_close(void *b)\n+{\n+\tint fd = ((struct file_block_source *)b)->fd;\n+\tif (fd > 0) {\n+\t\tclose(fd);\n+\t\t((struct file_block_source *)b)->fd = 0;\n+\t}\n+\n+\treftable_free(b);\n+}\n+\n+static int file_read_block(void *v, struct reftable_block *dest, uint64_t off,\n+\t\t\t uint32_t size)\n+{\n+\tstruct file_block_source *b = (struct file_block_source *)v;\n+\tassert(off + size <= b->size);\n+\tdest->data = reftable_malloc(size);\n+\tif (pread(b->fd, dest->data, size, off) != size)\n+\t\treturn -1;\n+\tdest->len = size;\n+\treturn size;\n+}\n+\n+struct reftable_block_source_vtable file_vtable = {\n+\t.size = &file_size,\n+\t.return_block = &file_return_block,\n+\t.close = &file_close,\n+};\n+\n+int reftable_block_source_from_file(struct reftable_block_source *bs,\n+\t\t\t\t const char *name)\n+{\n+\tstruct stat st = { 0 };\n+\tint err = 0;\n+\tint fd = open(name, O_RDONLY);\n+\tstruct file_block_source *p = NULL;\n+\tif (fd < 0) {\n+\t\tif (errno == ENOENT) {\n+\t\t\treturn REFTABLE_NOT_EXIST_ERROR;\n+\t\t}\n+\t\treturn -1;\n+\t}\n+\n+\terr = fstat(fd, &st);\n+\tif (err < 0)\n+\t\treturn -1;\n+\n+\tp = reftable_calloc(sizeof(struct file_block_source));\n+\tp->size = st.st_size;\n+\tp->fd = fd;\n+\n+\tassert(bs->ops == NULL);\n+\tbs->ops = &file_vtable;\n+\tbs->arg = p;\n+\treturn 0;\n+}\ndiff --git a/reftable/blocksource.h b/reftable/blocksource.h\nnew file mode 100644\nindex 0000000000..3faf83fa9d\n--- /dev/null\n+++ b/reftable/blocksource.h\n@@ -0,0 +1,22 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#ifndef BLOCKSOURCE_H\n+#define BLOCKSOURCE_H\n+\n+#include \"strbuf.h\"\n+\n+struct reftable_block_source;\n+\n+/* Create an in-memory block source for reading reftables */\n+void block_source_from_strbuf(struct reftable_block_source *bs,\n+\t\t\t struct strbuf *buf);\n+\n+struct reftable_block_source malloc_block_source(void);\n+\n+#endif\ndiff --git a/reftable/compat.c b/reftable/compat.c\nnew file mode 100644\nindex 0000000000..a48c5aa5e3\n--- /dev/null\n+++ b/reftable/compat.c\n@@ -0,0 +1,110 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+\n+*/\n+\n+/* compat.c - compatibility functions for standalone compilation */\n+\n+#include \"system.h\"\n+#include \"basics.h\"\n+\n+#ifdef REFTABLE_STANDALONE\n+\n+#include <dirent.h>\n+\n+void put_be32(void *p, uint32_t i)\n+{\n+\tuint8_t *out = (uint8_t *)p;\n+\n+\tout = (uint8_t)((i >> 24) & 0xff);\n+\tout = (uint8_t)((i >> 16) & 0xff);\n+\tout = (uint8_t)((i >> 8) & 0xff);\n+\tout = (uint8_t)((i)&0xff);\n+}\n+\n+uint32_t get_be32(uint8_t *in)\n+{\n+\treturn (uint32_t)(in) << 24 | (uint32_t)(in) << 16 |\n+\t (uint32_t)(in) << 8 | (uint32_t)(in);\n+}\n+\n+void put_be64(void *p, uint64_t v)\n+{\n+\tuint8_t *out = (uint8_t *)p;\n+\tint i = sizeof(uint64_t);\n+\twhile (i--) {\n+\t\tout[i] = (uint8_t)(v & 0xff);\n+\t\tv >>= 8;\n+\t}\n+}\n+\n+uint64_t get_be64(void *out)\n+{\n+\tuint8_t *bytes = (uint8_t *)out;\n+\tuint64_t v = 0;\n+\tint i = 0;\n+\tfor (i = 0; i < sizeof(uint64_t); i++) {\n+\t\tv = (v << 8) | (uint8_t)(bytes[i] & 0xff);\n+\t}\n+\treturn v;\n+}\n+\n+uint16_t get_be16(uint8_t *in)\n+{\n+\treturn (uint32_t)(in) << 8 | (uint32_t)(in);\n+}\n+\n+char *xstrdup(const char *s)\n+{\n+\tint l = strlen(s);\n+\tchar *dest = (char *)reftable_malloc(l + 1);\n+\tstrncpy(dest, s, l + 1);\n+\treturn dest;\n+}\n+\n+void sleep_millisec(int millisecs)\n+{\n+\tusleep(millisecs * 1000);\n+}\n+\n+void reftable_clear_dir(const char *dirname)\n+{\n+\tDIR *dir = opendir(dirname);\n+\tstruct dirent *ent = NULL;\n+\tassert(dir);\n+\twhile ((ent = readdir(dir)) != NULL) {\n+\t}\n+\tclosedir(dir);\n+\trmdir(dirname);\n+}\n+\n+#else\n+\n+#include \"../dir.h\"\n+\n+void reftable_clear_dir(const char *dirname)\n+{\n+\tstruct strbuf path = STRBUF_INIT;\n+\tremove_dir_recursively(&path, 0);\n+\tstrbuf_release(&path);\n+}\n+\n+#endif\n+\n+int hash_size(uint32_t id)\n+{\n+\tswitch (id) {\n+\tcase 0:\n+\tcase SHA1_ID:\n+\t\treturn SHA1_SIZE;\n+\tcase SHA256_ID:\n+\t\treturn SHA256_SIZE;\n+\t}\n+\tabort();\n+}\ndiff --git a/reftable/compat.h b/reftable/compat.h\nnew file mode 100644\nindex 0000000000..a765c57e96\n--- /dev/null\n+++ b/reftable/compat.h\n@@ -0,0 +1,48 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#ifndef COMPAT_H\n+#define COMPAT_H\n+\n+#include \"system.h\"\n+\n+#ifdef REFTABLE_STANDALONE\n+\n+/* functions that git-core provides, for standalone compilation */\n+#include <stdint.h>\n+\n+uint64_t get_be64(void *in);\n+void put_be64(void *out, uint64_t i);\n+\n+void put_be32(void *out, uint32_t i);\n+uint32_t get_be32(uint8_t *in);\n+\n+uint16_t get_be16(uint8_t *in);\n+\n+#define ARRAY_SIZE(a) sizeof((a)) / sizeof((a))\n+#define FREE_AND_NULL(x) \\\n+\tdo { \\\n+\t\treftable_free(x); \\\n+\t\t(x) = NULL; \\\n+\t} while (0)\n+#define QSORT(arr, n, cmp) qsort(arr, n, sizeof(arr), cmp)\n+#define SWAP(a, b) \\\n+\t{ \\\n+\t\tchar tmp[sizeof(a)]; \\\n+\t\tassert(sizeof(a) == sizeof(b)); \\\n+\t\tmemcpy(&tmp, &a, sizeof(a)); \\\n+\t\tmemcpy(&a, &b, sizeof(a)); \\\n+\t\tmemcpy(&b, &tmp, sizeof(a)); \\\n+\t}\n+\n+char *xstrdup(const char *s);\n+\n+void sleep_millisec(int millisecs);\n+\n+#endif\n+#endif\ndiff --git a/reftable/publicbasics.c b/reftable/publicbasics.c\nnew file mode 100644\nindex 0000000000..a31463ff9a\n--- /dev/null\n+++ b/reftable/publicbasics.c\n@@ -0,0 +1,100 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"reftable.h\"\n+\n+#include \"basics.h\"\n+#include \"system.h\"\n+\n+const char *reftable_error_str(int err)\n+{\n+\tstatic char buf;\n+\tswitch (err) {\n+\tcase REFTABLE_IO_ERROR:\n+\t\treturn \"I/O error\";\n+\tcase REFTABLE_FORMAT_ERROR:\n+\t\treturn \"corrupt reftable file\";\n+\tcase REFTABLE_NOT_EXIST_ERROR:\n+\t\treturn \"file does not exist\";\n+\tcase REFTABLE_LOCK_ERROR:\n+\t\treturn \"data is outdated\";\n+\tcase REFTABLE_API_ERROR:\n+\t\treturn \"misuse of the reftable API\";\n+\tcase REFTABLE_ZLIB_ERROR:\n+\t\treturn \"zlib failure\";\n+\tcase REFTABLE_NAME_CONFLICT:\n+\t\treturn \"file/directory conflict\";\n+\tcase REFTABLE_REFNAME_ERROR:\n+\t\treturn \"invalid refname\";\n+\tcase -1:\n+\t\treturn \"general error\";\n+\tdefault:\n+\t\tsnprintf(buf, sizeof(buf), \"unknown error code %d\", err);\n+\t\treturn buf;\n+\t}\n+}\n+\n+int reftable_error_to_errno(int err)\n+{\n+\tswitch (err) {\n+\tcase REFTABLE_IO_ERROR:\n+\t\treturn EIO;\n+\tcase REFTABLE_FORMAT_ERROR:\n+\t\treturn EFAULT;\n+\tcase REFTABLE_NOT_EXIST_ERROR:\n+\t\treturn ENOENT;\n+\tcase REFTABLE_LOCK_ERROR:\n+\t\treturn EBUSY;\n+\tcase REFTABLE_API_ERROR:\n+\t\treturn EINVAL;\n+\tcase REFTABLE_ZLIB_ERROR:\n+\t\treturn EDOM;\n+\tdefault:\n+\t\treturn ERANGE;\n+\t}\n+}\n+\n+void *(*reftable_malloc_ptr)(size_t sz) = &malloc;\n+void *(*reftable_realloc_ptr)(void *, size_t) = &realloc;\n+void (*reftable_free_ptr)(void *) = &free;\n+\n+void *reftable_malloc(size_t sz)\n+{\n+\treturn (*reftable_malloc_ptr)(sz);\n+}\n+\n+void *reftable_realloc(void *p, size_t sz)\n+{\n+\treturn (*reftable_realloc_ptr)(p, sz);\n+}\n+\n+void reftable_free(void *p)\n+{\n+\treftable_free_ptr(p);\n+}\n+\n+void *reftable_calloc(size_t sz)\n+{\n+\tvoid *p = reftable_malloc(sz);\n+\tmemset(p, 0, sz);\n+\treturn p;\n+}\n+\n+void reftable_set_alloc(void *(*malloc)(size_t),\n+\t\t\tvoid *(*realloc)(void *, size_t), void (*free)(void *))\n+{\n+\treftable_malloc_ptr = malloc;\n+\treftable_realloc_ptr = realloc;\n+\treftable_free_ptr = free;\n+}\n+\n+int reftable_fd_write(void *arg, const void *data, size_t sz)\n+{\n+\tint *fdp = (int *)arg;\n+\treturn write(*fdp, data, sz);\n+}\ndiff --git a/reftable/reftable-tests.h b/reftable/reftable-tests.h\nnew file mode 100644\nindex 0000000000..e38471888f\n--- /dev/null\n+++ b/reftable/reftable-tests.h\n@@ -0,0 +1,22 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#ifndef REFTABLE_TESTS_H\n+#define REFTABLE_TESTS_H\n+\n+int block_test_main(int argc, const char **argv);\n+int merged_test_main(int argc, const char **argv);\n+int record_test_main(int argc, const char **argv);\n+int refname_test_main(int argc, const char **argv);\n+int reftable_test_main(int argc, const char **argv);\n+int strbuf_test_main(int argc, const char **argv);\n+int stack_test_main(int argc, const char **argv);\n+int tree_test_main(int argc, const char **argv);\n+int reftable_dump_main(int argc, char *const *argv);\n+\n+#endif\ndiff --git a/reftable/strbuf.c b/reftable/strbuf.c\nnew file mode 100644\nindex 0000000000..136bf65591\n--- /dev/null\n+++ b/reftable/strbuf.c\n@@ -0,0 +1,142 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"strbuf.h\"\n+\n+#ifdef REFTABLE_STANDALONE\n+\n+void strbuf_init(struct strbuf *s, size_t alloc)\n+{\n+\tstruct strbuf empty = STRBUF_INIT;\n+\t*s = empty;\n+}\n+\n+void strbuf_grow(struct strbuf *s, size_t extra)\n+{\n+\tsize_t newcap = s->len + extra + 1;\n+\tif (newcap > s->cap) {\n+\t\ts->buf = reftable_realloc(s->buf, newcap);\n+\t\ts->cap = newcap;\n+\t}\n+}\n+\n+static void strbuf_resize(struct strbuf *s, int l)\n+{\n+\tint zl = l + 1; /* one uint8_t for 0 termination. */\n+\tassert(s->canary == STRBUF_CANARY);\n+\tif (s->cap < zl) {\n+\t\tint c = s->cap * 2;\n+\t\tif (c < zl) {\n+\t\t\tc = zl;\n+\t\t}\n+\t\ts->cap = c;\n+\t\ts->buf = reftable_realloc(s->buf, s->cap);\n+\t}\n+\ts->len = l;\n+\ts->buf[l] = 0;\n+}\n+\n+void strbuf_setlen(struct strbuf *s, size_t l)\n+{\n+\tassert(s->cap >= l + 1);\n+\ts->len = l;\n+\ts->buf[l] = 0;\n+}\n+\n+void strbuf_reset(struct strbuf *s)\n+{\n+\tstrbuf_resize(s, 0);\n+}\n+\n+void strbuf_addstr(struct strbuf *d, const char *s)\n+{\n+\tint l1 = d->len;\n+\tint l2 = strlen(s);\n+\tassert(d->canary == STRBUF_CANARY);\n+\n+\tstrbuf_resize(d, l2 + l1);\n+\tmemcpy(d->buf + l1, s, l2);\n+}\n+\n+void strbuf_addbuf(struct strbuf *s, struct strbuf *a)\n+{\n+\tint end = s->len;\n+\tassert(s->canary == STRBUF_CANARY);\n+\tstrbuf_resize(s, s->len + a->len);\n+\tmemcpy(s->buf + end, a->buf, a->len);\n+}\n+\n+char *strbuf_detach(struct strbuf *s, size_t *sz)\n+{\n+\tchar *p = NULL;\n+\tp = (char *)s->buf;\n+\tif (sz)\n+\t\t*sz = s->len;\n+\ts->buf = NULL;\n+\ts->cap = 0;\n+\ts->len = 0;\n+\treturn p;\n+}\n+\n+void strbuf_release(struct strbuf *s)\n+{\n+\tassert(s->canary == STRBUF_CANARY);\n+\ts->cap = 0;\n+\ts->len = 0;\n+\treftable_free(s->buf);\n+\ts->buf = NULL;\n+}\n+\n+int strbuf_cmp(const struct strbuf *a, const struct strbuf *b)\n+{\n+\tint min = a->len < b->len ? a->len : b->len;\n+\tint res = memcmp(a->buf, b->buf, min);\n+\tassert(a->canary == STRBUF_CANARY);\n+\tassert(b->canary == STRBUF_CANARY);\n+\tif (res != 0)\n+\t\treturn res;\n+\tif (a->len < b->len)\n+\t\treturn -1;\n+\telse if (a->len > b->len)\n+\t\treturn 1;\n+\telse\n+\t\treturn 0;\n+}\n+\n+int strbuf_add(struct strbuf *b, const void *data, size_t sz)\n+{\n+\tassert(b->canary == STRBUF_CANARY);\n+\tstrbuf_grow(b, sz);\n+\tmemcpy(b->buf + b->len, data, sz);\n+\tb->len += sz;\n+\tb->buf[b->len] = 0;\n+\treturn sz;\n+}\n+\n+#endif\n+\n+int strbuf_add_void(void *b, const void *data, size_t sz)\n+{\n+\tstrbuf_add((struct strbuf *)b, data, sz);\n+\treturn sz;\n+}\n+\n+int common_prefix_size(struct strbuf *a, struct strbuf *b)\n+{\n+\tint p = 0;\n+\twhile (p < a->len && p < b->len) {\n+\t\tif (a->buf[p] != b->buf[p]) {\n+\t\t\tbreak;\n+\t\t}\n+\t\tp++;\n+\t}\n+\n+\treturn p;\n+}\n+\n+struct strbuf reftable_empty_strbuf = STRBUF_INIT;\ndiff --git a/reftable/strbuf.h b/reftable/strbuf.h\nnew file mode 100644\nindex 0000000000..c2d7aca8dd\n--- /dev/null\n+++ b/reftable/strbuf.h\n@@ -0,0 +1,80 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#ifndef SLICE_H\n+#define SLICE_H\n+\n+#ifdef REFTABLE_STANDALONE\n+\n+#include \"basics.h\"\n+\n+/*\n+ Provides a bounds-checked, growable byte ranges. To use, initialize as \"strbuf\n+ x = STRBUF_INIT;\"\n+ */\n+struct strbuf {\n+\tsize_t len;\n+\tsize_t cap;\n+\tchar *buf;\n+\n+\t/* Used to enforce initialization with STRBUF_INIT */\n+\tuint8_t canary;\n+};\n+\n+#define STRBUF_CANARY 0x42\n+#define STRBUF_INIT \\\n+\t{ \\\n+\t\t0, 0, NULL, STRBUF_CANARY \\\n+\t}\n+\n+void strbuf_addstr(struct strbuf *dest, const char *src);\n+\n+/* Deallocate and clear strbuf */\n+void strbuf_release(struct strbuf *strbuf);\n+\n+/* Set strbuf to 0 length, but retain buffer. */\n+void strbuf_reset(struct strbuf *strbuf);\n+\n+/* Initializes a strbuf. Accepts a strbuf with random garbage. */\n+void strbuf_init(struct strbuf *strbuf, size_t alloc);\n+\n+/* Return `buf`, clearing out `s`. Optionally return len (not cap) in `sz`. */\n+char *strbuf_detach(struct strbuf *s, size_t *sz);\n+\n+/* Set length of the slace to `l`, but don't reallocated. */\n+void strbuf_setlen(struct strbuf *s, size_t l);\n+\n+/* Ensure `l` bytes beyond current length are available */\n+void strbuf_grow(struct strbuf *s, size_t l);\n+\n+/* Signed comparison */\n+int strbuf_cmp(const struct strbuf *a, const struct strbuf *b);\n+\n+/* Append `data` to the `dest` strbuf. */\n+int strbuf_add(struct strbuf *dest, const void *data, size_t sz);\n+\n+/* Append `add` to `dest. */\n+\n+#else\n+\n+#include \"../git-compat-util.h\"\n+#include \"../strbuf.h\"\n+\n+#endif\n+\n+extern struct strbuf reftable_empty_strbuf;\n+\n+/* Like strbuf_add, but suitable for passing to reftable_new_writer\n+ */\n+int strbuf_add_void(void *b, const void *data, size_t sz);\n+\n+/* Find the longest shared prefix size of `a` and `b` */\n+int common_prefix_size(struct strbuf *a, struct strbuf *b);\n+\n+#endif\ndiff --git a/reftable/strbuf_test.c b/reftable/strbuf_test.c\nnew file mode 100644\nindex 0000000000..39f561c81a\n--- /dev/null\n+++ b/reftable/strbuf_test.c\n@@ -0,0 +1,37 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"strbuf.h\"\n+\n+#include \"system.h\"\n+\n+#include \"basics.h\"\n+#include \"test_framework.h\"\n+#include \"reftable-tests.h\"\n+\n+static void test_strbuf(void)\n+{\n+\tstruct strbuf s = STRBUF_INIT;\n+\tstruct strbuf t = STRBUF_INIT;\n+\n+\tassert(0 == strcmp(\"abc\", s.buf));\n+\n+\tassert(0 == strcmp(\"abcpqr\", s.buf));\n+\n+\tstrbuf_release(&s);\n+\tstrbuf_release(&t);\n+}\n+\n+int strbuf_test_main(int argc, const char *argv[])\n+{\n+\treturn test_main(argc, argv);\n+}\ndiff --git a/reftable/system.h b/reftable/system.h\nnew file mode 100644\nindex 0000000000..567eb8a87d\n--- /dev/null\n+++ b/reftable/system.h\n@@ -0,0 +1,51 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#ifndef SYSTEM_H\n+#define SYSTEM_H\n+\n+#ifndef REFTABLE_STANDALONE\n+\n+#include \"git-compat-util.h\"\n+#include \"cache.h\"\n+#include <zlib.h>\n+\n+#else\n+\n+#include <assert.h>\n+#include <errno.h>\n+#include <fcntl.h>\n+#include <inttypes.h>\n+#include <stdint.h>\n+#include <stdio.h>\n+#include <stdlib.h>\n+#include <string.h>\n+#include <sys/stat.h>\n+#include <sys/time.h>\n+#include <sys/types.h>\n+#include <unistd.h>\n+#include <zlib.h>\n+\n+#include \"compat.h\"\n+\n+#endif /* REFTABLE_STANDALONE */\n+\n+void reftable_clear_dir(const char *dirname);\n+\n+#define SHA1_ID 0x73686131\n+#define SHA256_ID 0x73323536\n+#define SHA1_SIZE 20\n+#define SHA256_SIZE 32\n+\n+/* This is uncompress2, which is only available in zlib as of 2017.\n+ */\n+int uncompress_return_consumed(Bytef *dest, uLongf *destLen,\n+\t\t\t const Bytef *source, uLong *sourceLen);\n+int hash_size(uint32_t id);\n+\n+#endif\ndiff --git a/t/helper/test-reftable.c b/t/helper/test-reftable.c\nnew file mode 100644\nindex 0000000000..7d50aa6bcc\n--- /dev/null\n+++ b/t/helper/test-reftable.c\n@@ -0,0 +1,8 @@\n+#include \"reftable/reftable-tests.h\"\n+#include \"test-tool.h\"\n+\n+int cmd__reftable(int argc, const char **argv)\n+{\n+\tstrbuf_test_main(argc, argv);\n+\treturn 0;\n+}\ndiff --git a/t/helper/test-tool.c b/t/helper/test-tool.c\nindex 590b2efca7..10366b7b76 100644\n--- a/t/helper/test-tool.c\n+++ b/t/helper/test-tool.c\n@@ -52,6 +52,7 @@ static struct test_cmd cmds[] = {\n{ \"ref-store\", cmd__ref_store },\n+\t{ \"reftable\", cmd__reftable },\n{ \"regex\", cmd__regex },\n{ \"repository\", cmd__repository },\n{ \"revision-walking\", cmd__revision_walking },\ndiff --git a/t/helper/test-tool.h b/t/helper/test-tool.h\nindex ddc8e990e9..d52ba2f5e5 100644\n--- a/t/helper/test-tool.h\n+++ b/t/helper/test-tool.h\n@@ -41,6 +41,7 @@ int cmd__read_cache(int argc, const char **argv);\nint cmd__read_graph(int argc, const char **argv);\nint cmd__read_midx(int argc, const char **argv);\nint cmd__ref_store(int argc, const char **argv);\n+int cmd__reftable(int argc, const char **argv);\nint cmd__regex(int argc, const char **argv);\nint cmd__repository(int argc, const char **argv);\nint cmd__revision_walking(int argc, const char **argv);\n--\n\n• ```* [PATCH 06/13] reftable: (de)serialization for the polymorphic record type.\n2020-09-16 19:10 [PATCH 00/13] reftable library Han-Wen Nienhuys via GitGitGadget\n` (4 preceding siblings ...)\n2020-09-16 19:10 ` [PATCH 05/13] reftable: utility functions Han-Wen Nienhuys via GitGitGadget\n@ 2020-09-16 19:10 ` Han-Wen Nienhuys via GitGitGadget\n2020-09-20 1:00 ` Junio C Hamano\n2020-09-16 19:10 ` [PATCH 07/13] reftable: reading/writing blocks Han-Wen Nienhuys via GitGitGadget\n` (7 subsequent siblings)\nFrom: Han-Wen Nienhuys via GitGitGadget @ 2020-09-16 19:10 UTC (permalink / raw)\nTo: git; +Cc: Han-Wen Nienhuys, Han-Wen Nienhuys\n\n---\nMakefile | 2 +\nreftable/constants.h | 21 +\nreftable/record.c | 1114 ++++++++++++++++++++++++++++++++++++++\nreftable/record.h | 143 +++++\nreftable/record_test.c | 410 ++++++++++++++\nt/helper/test-reftable.c | 1 +\n6 files changed, 1691 insertions(+)\ncreate mode 100644 reftable/constants.h\ncreate mode 100644 reftable/record.c\ncreate mode 100644 reftable/record.h\ncreate mode 100644 reftable/record_test.c\n\ndiff --git a/Makefile b/Makefile\nindex 66158525a9..0fb0048c34 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -2348,8 +2348,10 @@ REFTABLE_OBJS += reftable/basics.o\nREFTABLE_OBJS += reftable/blocksource.o\nREFTABLE_OBJS += reftable/publicbasics.o\nREFTABLE_OBJS += reftable/compat.o\n+REFTABLE_OBJS += reftable/record.o\nREFTABLE_OBJS += reftable/strbuf.o\n\n+REFTABLE_TEST_OBJS += reftable/record_test.o\nREFTABLE_TEST_OBJS += reftable/strbuf_test.o\nREFTABLE_TEST_OBJS += reftable/test_framework.o\n\ndiff --git a/reftable/constants.h b/reftable/constants.h\nnew file mode 100644\nindex 0000000000..5eee72c4c1\n--- /dev/null\n+++ b/reftable/constants.h\n@@ -0,0 +1,21 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#ifndef CONSTANTS_H\n+#define CONSTANTS_H\n+\n+#define BLOCK_TYPE_LOG 'g'\n+#define BLOCK_TYPE_INDEX 'i'\n+#define BLOCK_TYPE_REF 'r'\n+#define BLOCK_TYPE_OBJ 'o'\n+#define BLOCK_TYPE_ANY 0\n+\n+#define MAX_RESTARTS ((1 << 16) - 1)\n+#define DEFAULT_BLOCK_SIZE 4096\n+\n+#endif\ndiff --git a/reftable/record.c b/reftable/record.c\nnew file mode 100644\nindex 0000000000..21c9bba077\n--- /dev/null\n+++ b/reftable/record.c\n@@ -0,0 +1,1114 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+/* record.c - methods for different types of records. */\n+\n+#include \"record.h\"\n+\n+#include \"system.h\"\n+#include \"constants.h\"\n+#include \"reftable.h\"\n+#include \"basics.h\"\n+\n+int get_var_int(uint64_t *dest, struct string_view *in)\n+{\n+\tint ptr = 0;\n+\tuint64_t val;\n+\n+\tif (in->len == 0)\n+\t\treturn -1;\n+\tval = in->buf[ptr] & 0x7f;\n+\n+\twhile (in->buf[ptr] & 0x80) {\n+\t\tptr++;\n+\t\tif (ptr > in->len) {\n+\t\t\treturn -1;\n+\t\t}\n+\t\tval = (val + 1) << 7 | (uint64_t)(in->buf[ptr] & 0x7f);\n+\t}\n+\n+\t*dest = val;\n+\treturn ptr + 1;\n+}\n+\n+int put_var_int(struct string_view *dest, uint64_t val)\n+{\n+\tuint8_t buf = { 0 };\n+\tint i = 9;\n+\tint n = 0;\n+\tbuf[i] = (uint8_t)(val & 0x7f);\n+\ti--;\n+\twhile (1) {\n+\t\tval >>= 7;\n+\t\tif (!val) {\n+\t\t\tbreak;\n+\t\t}\n+\t\tval--;\n+\t\tbuf[i] = 0x80 | (uint8_t)(val & 0x7f);\n+\t\ti--;\n+\t}\n+\n+\tn = sizeof(buf) - i - 1;\n+\tif (dest->len < n)\n+\t\treturn -1;\n+\tmemcpy(dest->buf, &buf[i + 1], n);\n+\treturn n;\n+}\n+\n+int reftable_is_block_type(uint8_t typ)\n+{\n+\tswitch (typ) {\n+\tcase BLOCK_TYPE_REF:\n+\tcase BLOCK_TYPE_LOG:\n+\tcase BLOCK_TYPE_OBJ:\n+\tcase BLOCK_TYPE_INDEX:\n+\t\treturn 1;\n+\t}\n+\treturn 0;\n+}\n+\n+static int decode_string(struct strbuf *dest, struct string_view in)\n+{\n+\tint start_len = in.len;\n+\tuint64_t tsize = 0;\n+\tint n = get_var_int(&tsize, &in);\n+\tif (n <= 0)\n+\t\treturn -1;\n+\tstring_view_consume(&in, n);\n+\tif (in.len < tsize)\n+\t\treturn -1;\n+\n+\tstrbuf_reset(dest);\n+\tstring_view_consume(&in, tsize);\n+\n+\treturn start_len - in.len;\n+}\n+\n+static int encode_string(char *str, struct string_view s)\n+{\n+\tstruct string_view start = s;\n+\tint l = strlen(str);\n+\tint n = put_var_int(&s, l);\n+\tif (n < 0)\n+\t\treturn -1;\n+\tstring_view_consume(&s, n);\n+\tif (s.len < l)\n+\t\treturn -1;\n+\tmemcpy(s.buf, str, l);\n+\tstring_view_consume(&s, l);\n+\n+\treturn start.len - s.len;\n+}\n+\n+int reftable_encode_key(int *restart, struct string_view dest,\n+\t\t\tstruct strbuf prev_key, struct strbuf key,\n+\t\t\tuint8_t extra)\n+{\n+\tstruct string_view start = dest;\n+\tint prefix_len = common_prefix_size(&prev_key, &key);\n+\tuint64_t suffix_len = key.len - prefix_len;\n+\tint n = put_var_int(&dest, (uint64_t)prefix_len);\n+\tif (n < 0)\n+\t\treturn -1;\n+\tstring_view_consume(&dest, n);\n+\n+\t*restart = (prefix_len == 0);\n+\n+\tn = put_var_int(&dest, suffix_len << 3 | (uint64_t)extra);\n+\tif (n < 0)\n+\t\treturn -1;\n+\tstring_view_consume(&dest, n);\n+\n+\tif (dest.len < suffix_len)\n+\t\treturn -1;\n+\tmemcpy(dest.buf, key.buf + prefix_len, suffix_len);\n+\tstring_view_consume(&dest, suffix_len);\n+\n+\treturn start.len - dest.len;\n+}\n+\n+int reftable_decode_key(struct strbuf *key, uint8_t *extra,\n+\t\t\tstruct strbuf last_key, struct string_view in)\n+{\n+\tint start_len = in.len;\n+\tuint64_t prefix_len = 0;\n+\tuint64_t suffix_len = 0;\n+\tint n = get_var_int(&prefix_len, &in);\n+\tif (n < 0)\n+\t\treturn -1;\n+\tstring_view_consume(&in, n);\n+\n+\tif (prefix_len > last_key.len)\n+\t\treturn -1;\n+\n+\tn = get_var_int(&suffix_len, &in);\n+\tif (n <= 0)\n+\t\treturn -1;\n+\tstring_view_consume(&in, n);\n+\n+\t*extra = (uint8_t)(suffix_len & 0x7);\n+\tsuffix_len >>= 3;\n+\n+\tif (in.len < suffix_len)\n+\t\treturn -1;\n+\n+\tstrbuf_reset(key);\n+\tstring_view_consume(&in, suffix_len);\n+\n+\treturn start_len - in.len;\n+}\n+\n+static void reftable_ref_record_key(const void *r, struct strbuf *dest)\n+{\n+\tconst struct reftable_ref_record *rec =\n+\t\t(const struct reftable_ref_record *)r;\n+\tstrbuf_reset(dest);\n+}\n+\n+static void reftable_ref_record_copy_from(void *rec, const void *src_rec,\n+\t\t\t\t\t int hash_size)\n+{\n+\tstruct reftable_ref_record *ref = (struct reftable_ref_record *)rec;\n+\tstruct reftable_ref_record *src = (struct reftable_ref_record *)src_rec;\n+\tassert(hash_size > 0);\n+\n+\t/* This is simple and correct, but we could probably reuse the hash\n+\t fields. */\n+\treftable_ref_record_clear(ref);\n+\tif (src->refname != NULL) {\n+\t\tref->refname = xstrdup(src->refname);\n+\t}\n+\n+\tif (src->target != NULL) {\n+\t\tref->target = xstrdup(src->target);\n+\t}\n+\n+\tif (src->target_value != NULL) {\n+\t\tref->target_value = reftable_malloc(hash_size);\n+\t\tmemcpy(ref->target_value, src->target_value, hash_size);\n+\t}\n+\n+\tif (src->value != NULL) {\n+\t\tref->value = reftable_malloc(hash_size);\n+\t\tmemcpy(ref->value, src->value, hash_size);\n+\t}\n+\tref->update_index = src->update_index;\n+}\n+\n+static char hexdigit(int c)\n+{\n+\tif (c <= 9)\n+\t\treturn '0' + c;\n+\treturn 'a' + (c - 10);\n+}\n+\n+static void hex_format(char *dest, uint8_t *src, int hash_size)\n+{\n+\tassert(hash_size > 0);\n+\tif (src != NULL) {\n+\t\tint i = 0;\n+\t\tfor (i = 0; i < hash_size; i++) {\n+\t\t\tdest[2 * i] = hexdigit(src[i] >> 4);\n+\t\t\tdest[2 * i + 1] = hexdigit(src[i] & 0xf);\n+\t\t}\n+\t\tdest[2 * hash_size] = 0;\n+\t}\n+}\n+\n+void reftable_ref_record_print(struct reftable_ref_record *ref,\n+\t\t\t uint32_t hash_id)\n+{\n+\tchar hex[SHA256_SIZE + 1] = { 0 };\n+\tprintf(\"ref{%s(%\" PRIu64 \") \", ref->refname, ref->update_index);\n+\tif (ref->value != NULL) {\n+\t\thex_format(hex, ref->value, hash_size(hash_id));\n+\t\tprintf(\"%s\", hex);\n+\t}\n+\tif (ref->target_value != NULL) {\n+\t\thex_format(hex, ref->target_value, hash_size(hash_id));\n+\t\tprintf(\" (T %s)\", hex);\n+\t}\n+\tif (ref->target != NULL) {\n+\t\tprintf(\"=> %s\", ref->target);\n+\t}\n+\tprintf(\"}\\n\");\n+}\n+\n+static void reftable_ref_record_clear_void(void *rec)\n+{\n+\treftable_ref_record_clear((struct reftable_ref_record *)rec);\n+}\n+\n+void reftable_ref_record_clear(struct reftable_ref_record *ref)\n+{\n+\treftable_free(ref->refname);\n+\treftable_free(ref->target);\n+\treftable_free(ref->target_value);\n+\treftable_free(ref->value);\n+\tmemset(ref, 0, sizeof(struct reftable_ref_record));\n+}\n+\n+static uint8_t reftable_ref_record_val_type(const void *rec)\n+{\n+\tconst struct reftable_ref_record *r =\n+\t\t(const struct reftable_ref_record *)rec;\n+\tif (r->value != NULL) {\n+\t\tif (r->target_value != NULL) {\n+\t\t\treturn 2;\n+\t\t} else {\n+\t\t\treturn 1;\n+\t\t}\n+\t} else if (r->target != NULL)\n+\t\treturn 3;\n+\treturn 0;\n+}\n+\n+static int reftable_ref_record_encode(const void *rec, struct string_view s,\n+\t\t\t\t int hash_size)\n+{\n+\tconst struct reftable_ref_record *r =\n+\t\t(const struct reftable_ref_record *)rec;\n+\tstruct string_view start = s;\n+\tint n = put_var_int(&s, r->update_index);\n+\tassert(hash_size > 0);\n+\tif (n < 0)\n+\t\treturn -1;\n+\tstring_view_consume(&s, n);\n+\n+\tif (r->value != NULL) {\n+\t\tif (s.len < hash_size) {\n+\t\t\treturn -1;\n+\t\t}\n+\t\tmemcpy(s.buf, r->value, hash_size);\n+\t\tstring_view_consume(&s, hash_size);\n+\t}\n+\n+\tif (r->target_value != NULL) {\n+\t\tif (s.len < hash_size) {\n+\t\t\treturn -1;\n+\t\t}\n+\t\tmemcpy(s.buf, r->target_value, hash_size);\n+\t\tstring_view_consume(&s, hash_size);\n+\t}\n+\n+\tif (r->target != NULL) {\n+\t\tint n = encode_string(r->target, s);\n+\t\tif (n < 0) {\n+\t\t\treturn -1;\n+\t\t}\n+\t\tstring_view_consume(&s, n);\n+\t}\n+\n+\treturn start.len - s.len;\n+}\n+\n+static int reftable_ref_record_decode(void *rec, struct strbuf key,\n+\t\t\t\t uint8_t val_type, struct string_view in,\n+\t\t\t\t int hash_size)\n+{\n+\tstruct reftable_ref_record *r = (struct reftable_ref_record *)rec;\n+\tstruct string_view start = in;\n+\tint seen_value = 0;\n+\tint seen_target_value = 0;\n+\tint seen_target = 0;\n+\n+\tint n = get_var_int(&r->update_index, &in);\n+\tif (n < 0)\n+\t\treturn n;\n+\tassert(hash_size > 0);\n+\n+\tstring_view_consume(&in, n);\n+\n+\tr->refname = reftable_realloc(r->refname, key.len + 1);\n+\tmemcpy(r->refname, key.buf, key.len);\n+\tr->refname[key.len] = 0;\n+\n+\tswitch (val_type) {\n+\tcase 1:\n+\tcase 2:\n+\t\tif (in.len < hash_size) {\n+\t\t\treturn -1;\n+\t\t}\n+\n+\t\tif (r->value == NULL) {\n+\t\t\tr->value = reftable_malloc(hash_size);\n+\t\t}\n+\t\tseen_value = 1;\n+\t\tmemcpy(r->value, in.buf, hash_size);\n+\t\tstring_view_consume(&in, hash_size);\n+\t\tif (val_type == 1) {\n+\t\t\tbreak;\n+\t\t}\n+\t\tif (r->target_value == NULL) {\n+\t\t\tr->target_value = reftable_malloc(hash_size);\n+\t\t}\n+\t\tseen_target_value = 1;\n+\t\tmemcpy(r->target_value, in.buf, hash_size);\n+\t\tstring_view_consume(&in, hash_size);\n+\t\tbreak;\n+\tcase 3: {\n+\t\tstruct strbuf dest = STRBUF_INIT;\n+\t\tint n = decode_string(&dest, in);\n+\t\tif (n < 0) {\n+\t\t\treturn -1;\n+\t\t}\n+\t\tstring_view_consume(&in, n);\n+\t\tseen_target = 1;\n+\t\tif (r->target != NULL) {\n+\t\t\treftable_free(r->target);\n+\t\t}\n+\t\tr->target = dest.buf;\n+\t} break;\n+\n+\tcase 0:\n+\t\tbreak;\n+\tdefault:\n+\t\tabort();\n+\t\tbreak;\n+\t}\n+\n+\tif (!seen_target && r->target != NULL) {\n+\t\tFREE_AND_NULL(r->target);\n+\t}\n+\tif (!seen_target_value && r->target_value != NULL) {\n+\t\tFREE_AND_NULL(r->target_value);\n+\t}\n+\tif (!seen_value && r->value != NULL) {\n+\t\tFREE_AND_NULL(r->value);\n+\t}\n+\n+\treturn start.len - in.len;\n+}\n+\n+static int reftable_ref_record_is_deletion_void(const void *p)\n+{\n+\treturn reftable_ref_record_is_deletion(\n+\t\t(const struct reftable_ref_record *)p);\n+}\n+\n+struct reftable_record_vtable reftable_ref_record_vtable = {\n+\t.key = &reftable_ref_record_key,\n+\t.type = BLOCK_TYPE_REF,\n+\t.copy_from = &reftable_ref_record_copy_from,\n+\t.val_type = &reftable_ref_record_val_type,\n+\t.encode = &reftable_ref_record_encode,\n+\t.decode = &reftable_ref_record_decode,\n+\t.clear = &reftable_ref_record_clear_void,\n+\t.is_deletion = &reftable_ref_record_is_deletion_void,\n+};\n+\n+static void reftable_obj_record_key(const void *r, struct strbuf *dest)\n+{\n+\tconst struct reftable_obj_record *rec =\n+\t\t(const struct reftable_obj_record *)r;\n+\tstrbuf_reset(dest);\n+}\n+\n+static void reftable_obj_record_clear(void *rec)\n+{\n+\tstruct reftable_obj_record *obj = (struct reftable_obj_record *)rec;\n+\tFREE_AND_NULL(obj->hash_prefix);\n+\tFREE_AND_NULL(obj->offsets);\n+\tmemset(obj, 0, sizeof(struct reftable_obj_record));\n+}\n+\n+static void reftable_obj_record_copy_from(void *rec, const void *src_rec,\n+\t\t\t\t\t int hash_size)\n+{\n+\tstruct reftable_obj_record *obj = (struct reftable_obj_record *)rec;\n+\tconst struct reftable_obj_record *src =\n+\t\t(const struct reftable_obj_record *)src_rec;\n+\tint olen;\n+\n+\treftable_obj_record_clear(obj);\n+\t*obj = *src;\n+\tobj->hash_prefix = reftable_malloc(obj->hash_prefix_len);\n+\tmemcpy(obj->hash_prefix, src->hash_prefix, obj->hash_prefix_len);\n+\n+\tolen = obj->offset_len * sizeof(uint64_t);\n+\tobj->offsets = reftable_malloc(olen);\n+\tmemcpy(obj->offsets, src->offsets, olen);\n+}\n+\n+static uint8_t reftable_obj_record_val_type(const void *rec)\n+{\n+\tstruct reftable_obj_record *r = (struct reftable_obj_record *)rec;\n+\tif (r->offset_len > 0 && r->offset_len < 8)\n+\t\treturn r->offset_len;\n+\treturn 0;\n+}\n+\n+static int reftable_obj_record_encode(const void *rec, struct string_view s,\n+\t\t\t\t int hash_size)\n+{\n+\tstruct reftable_obj_record *r = (struct reftable_obj_record *)rec;\n+\tstruct string_view start = s;\n+\tint i = 0;\n+\tint n = 0;\n+\tuint64_t last = 0;\n+\tif (r->offset_len == 0 || r->offset_len >= 8) {\n+\t\tn = put_var_int(&s, r->offset_len);\n+\t\tif (n < 0) {\n+\t\t\treturn -1;\n+\t\t}\n+\t\tstring_view_consume(&s, n);\n+\t}\n+\tif (r->offset_len == 0)\n+\t\treturn start.len - s.len;\n+\tn = put_var_int(&s, r->offsets);\n+\tif (n < 0)\n+\t\treturn -1;\n+\tstring_view_consume(&s, n);\n+\n+\tlast = r->offsets;\n+\tfor (i = 1; i < r->offset_len; i++) {\n+\t\tint n = put_var_int(&s, r->offsets[i] - last);\n+\t\tif (n < 0) {\n+\t\t\treturn -1;\n+\t\t}\n+\t\tstring_view_consume(&s, n);\n+\t\tlast = r->offsets[i];\n+\t}\n+\treturn start.len - s.len;\n+}\n+\n+static int reftable_obj_record_decode(void *rec, struct strbuf key,\n+\t\t\t\t uint8_t val_type, struct string_view in,\n+\t\t\t\t int hash_size)\n+{\n+\tstruct string_view start = in;\n+\tstruct reftable_obj_record *r = (struct reftable_obj_record *)rec;\n+\tuint64_t count = val_type;\n+\tint n = 0;\n+\tuint64_t last;\n+\tint j;\n+\tr->hash_prefix = reftable_malloc(key.len);\n+\tmemcpy(r->hash_prefix, key.buf, key.len);\n+\tr->hash_prefix_len = key.len;\n+\n+\tif (val_type == 0) {\n+\t\tn = get_var_int(&count, &in);\n+\t\tif (n < 0) {\n+\t\t\treturn n;\n+\t\t}\n+\n+\t\tstring_view_consume(&in, n);\n+\t}\n+\n+\tr->offsets = NULL;\n+\tr->offset_len = 0;\n+\tif (count == 0)\n+\t\treturn start.len - in.len;\n+\n+\tr->offsets = reftable_malloc(count * sizeof(uint64_t));\n+\tr->offset_len = count;\n+\n+\tn = get_var_int(&r->offsets, &in);\n+\tif (n < 0)\n+\t\treturn n;\n+\tstring_view_consume(&in, n);\n+\n+\tlast = r->offsets;\n+\tj = 1;\n+\twhile (j < count) {\n+\t\tuint64_t delta = 0;\n+\t\tint n = get_var_int(&delta, &in);\n+\t\tif (n < 0) {\n+\t\t\treturn n;\n+\t\t}\n+\t\tstring_view_consume(&in, n);\n+\n+\t\tlast = r->offsets[j] = (delta + last);\n+\t\tj++;\n+\t}\n+\treturn start.len - in.len;\n+}\n+\n+static int not_a_deletion(const void *p)\n+{\n+\treturn 0;\n+}\n+\n+struct reftable_record_vtable reftable_obj_record_vtable = {\n+\t.key = &reftable_obj_record_key,\n+\t.type = BLOCK_TYPE_OBJ,\n+\t.copy_from = &reftable_obj_record_copy_from,\n+\t.val_type = &reftable_obj_record_val_type,\n+\t.encode = &reftable_obj_record_encode,\n+\t.decode = &reftable_obj_record_decode,\n+\t.clear = &reftable_obj_record_clear,\n+\t.is_deletion = not_a_deletion,\n+};\n+\n+void reftable_log_record_print(struct reftable_log_record *log,\n+\t\t\t uint32_t hash_id)\n+{\n+\tchar hex[SHA256_SIZE + 1] = { 0 };\n+\n+\tprintf(\"log{%s(%\" PRIu64 \") %s <%s> %\" PRIu64 \" %04d\\n\", log->refname,\n+\t log->update_index, log->name, log->email, log->time,\n+\t log->tz_offset);\n+\thex_format(hex, log->old_hash, hash_size(hash_id));\n+\tprintf(\"%s => \", hex);\n+\thex_format(hex, log->new_hash, hash_size(hash_id));\n+\tprintf(\"%s\\n\\n%s\\n}\\n\", hex, log->message);\n+}\n+\n+static void reftable_log_record_key(const void *r, struct strbuf *dest)\n+{\n+\tconst struct reftable_log_record *rec =\n+\t\t(const struct reftable_log_record *)r;\n+\tint len = strlen(rec->refname);\n+\tuint8_t i64;\n+\tuint64_t ts = 0;\n+\tstrbuf_reset(dest);\n+\tstrbuf_add(dest, (uint8_t *)rec->refname, len + 1);\n+\n+\tts = (~ts) - rec->update_index;\n+\tput_be64(&i64, ts);\n+}\n+\n+static void reftable_log_record_copy_from(void *rec, const void *src_rec,\n+\t\t\t\t\t int hash_size)\n+{\n+\tstruct reftable_log_record *dst = (struct reftable_log_record *)rec;\n+\tconst struct reftable_log_record *src =\n+\t\t(const struct reftable_log_record *)src_rec;\n+\n+\treftable_log_record_clear(dst);\n+\t*dst = *src;\n+\tif (dst->refname != NULL) {\n+\t\tdst->refname = xstrdup(dst->refname);\n+\t}\n+\tif (dst->email != NULL) {\n+\t\tdst->email = xstrdup(dst->email);\n+\t}\n+\tif (dst->name != NULL) {\n+\t\tdst->name = xstrdup(dst->name);\n+\t}\n+\tif (dst->message != NULL) {\n+\t\tdst->message = xstrdup(dst->message);\n+\t}\n+\n+\tif (dst->new_hash != NULL) {\n+\t\tdst->new_hash = reftable_malloc(hash_size);\n+\t\tmemcpy(dst->new_hash, src->new_hash, hash_size);\n+\t}\n+\tif (dst->old_hash != NULL) {\n+\t\tdst->old_hash = reftable_malloc(hash_size);\n+\t\tmemcpy(dst->old_hash, src->old_hash, hash_size);\n+\t}\n+}\n+\n+static void reftable_log_record_clear_void(void *rec)\n+{\n+\tstruct reftable_log_record *r = (struct reftable_log_record *)rec;\n+\treftable_log_record_clear(r);\n+}\n+\n+void reftable_log_record_clear(struct reftable_log_record *r)\n+{\n+\treftable_free(r->refname);\n+\treftable_free(r->new_hash);\n+\treftable_free(r->old_hash);\n+\treftable_free(r->name);\n+\treftable_free(r->email);\n+\treftable_free(r->message);\n+\tmemset(r, 0, sizeof(struct reftable_log_record));\n+}\n+\n+static uint8_t reftable_log_record_val_type(const void *rec)\n+{\n+\tconst struct reftable_log_record *log =\n+\t\t(const struct reftable_log_record *)rec;\n+\n+\treturn reftable_log_record_is_deletion(log) ? 0 : 1;\n+}\n+\n+static uint8_t zero[SHA256_SIZE] = { 0 };\n+\n+static int reftable_log_record_encode(const void *rec, struct string_view s,\n+\t\t\t\t int hash_size)\n+{\n+\tstruct reftable_log_record *r = (struct reftable_log_record *)rec;\n+\tstruct string_view start = s;\n+\tint n = 0;\n+\tuint8_t *oldh = r->old_hash;\n+\tuint8_t *newh = r->new_hash;\n+\tif (reftable_log_record_is_deletion(r))\n+\t\treturn 0;\n+\n+\tif (oldh == NULL) {\n+\t\toldh = zero;\n+\t}\n+\tif (newh == NULL) {\n+\t\tnewh = zero;\n+\t}\n+\n+\tif (s.len < 2 * hash_size)\n+\t\treturn -1;\n+\n+\tmemcpy(s.buf, oldh, hash_size);\n+\tmemcpy(s.buf + hash_size, newh, hash_size);\n+\tstring_view_consume(&s, 2 * hash_size);\n+\n+\tn = encode_string(r->name ? r->name : \"\", s);\n+\tif (n < 0)\n+\t\treturn -1;\n+\tstring_view_consume(&s, n);\n+\n+\tn = encode_string(r->email ? r->email : \"\", s);\n+\tif (n < 0)\n+\t\treturn -1;\n+\tstring_view_consume(&s, n);\n+\n+\tn = put_var_int(&s, r->time);\n+\tif (n < 0)\n+\t\treturn -1;\n+\tstring_view_consume(&s, n);\n+\n+\tif (s.len < 2)\n+\t\treturn -1;\n+\n+\tput_be16(s.buf, r->tz_offset);\n+\tstring_view_consume(&s, 2);\n+\n+\tn = encode_string(r->message ? r->message : \"\", s);\n+\tif (n < 0)\n+\t\treturn -1;\n+\tstring_view_consume(&s, n);\n+\n+\treturn start.len - s.len;\n+}\n+\n+static int reftable_log_record_decode(void *rec, struct strbuf key,\n+\t\t\t\t uint8_t val_type, struct string_view in,\n+\t\t\t\t int hash_size)\n+{\n+\tstruct string_view start = in;\n+\tstruct reftable_log_record *r = (struct reftable_log_record *)rec;\n+\tuint64_t max = 0;\n+\tuint64_t ts = 0;\n+\tstruct strbuf dest = STRBUF_INIT;\n+\tint n;\n+\n+\tif (key.len <= 9 || key.buf[key.len - 9] != 0)\n+\t\treturn REFTABLE_FORMAT_ERROR;\n+\n+\tr->refname = reftable_realloc(r->refname, key.len - 8);\n+\tmemcpy(r->refname, key.buf, key.len - 8);\n+\tts = get_be64(key.buf + key.len - 8);\n+\n+\tr->update_index = (~max) - ts;\n+\n+\tif (val_type == 0) {\n+\t\tFREE_AND_NULL(r->old_hash);\n+\t\tFREE_AND_NULL(r->new_hash);\n+\t\tFREE_AND_NULL(r->message);\n+\t\tFREE_AND_NULL(r->email);\n+\t\tFREE_AND_NULL(r->name);\n+\t\treturn 0;\n+\t}\n+\n+\tif (in.len < 2 * hash_size)\n+\t\treturn REFTABLE_FORMAT_ERROR;\n+\n+\tr->old_hash = reftable_realloc(r->old_hash, hash_size);\n+\tr->new_hash = reftable_realloc(r->new_hash, hash_size);\n+\n+\tmemcpy(r->old_hash, in.buf, hash_size);\n+\tmemcpy(r->new_hash, in.buf + hash_size, hash_size);\n+\n+\tstring_view_consume(&in, 2 * hash_size);\n+\n+\tn = decode_string(&dest, in);\n+\tif (n < 0)\n+\t\tgoto done;\n+\tstring_view_consume(&in, n);\n+\n+\tr->name = reftable_realloc(r->name, dest.len + 1);\n+\tmemcpy(r->name, dest.buf, dest.len);\n+\tr->name[dest.len] = 0;\n+\n+\tstrbuf_reset(&dest);\n+\tn = decode_string(&dest, in);\n+\tif (n < 0)\n+\t\tgoto done;\n+\tstring_view_consume(&in, n);\n+\n+\tr->email = reftable_realloc(r->email, dest.len + 1);\n+\tmemcpy(r->email, dest.buf, dest.len);\n+\tr->email[dest.len] = 0;\n+\n+\tts = 0;\n+\tn = get_var_int(&ts, &in);\n+\tif (n < 0)\n+\t\tgoto done;\n+\tstring_view_consume(&in, n);\n+\tr->time = ts;\n+\tif (in.len < 2)\n+\t\tgoto done;\n+\n+\tr->tz_offset = get_be16(in.buf);\n+\tstring_view_consume(&in, 2);\n+\n+\tstrbuf_reset(&dest);\n+\tn = decode_string(&dest, in);\n+\tif (n < 0)\n+\t\tgoto done;\n+\tstring_view_consume(&in, n);\n+\n+\tr->message = reftable_realloc(r->message, dest.len + 1);\n+\tmemcpy(r->message, dest.buf, dest.len);\n+\tr->message[dest.len] = 0;\n+\n+\tstrbuf_release(&dest);\n+\treturn start.len - in.len;\n+\n+done:\n+\tstrbuf_release(&dest);\n+\treturn REFTABLE_FORMAT_ERROR;\n+}\n+\n+static int null_streq(char *a, char *b)\n+{\n+\tchar *empty = \"\";\n+\tif (a == NULL)\n+\t\ta = empty;\n+\n+\tif (b == NULL)\n+\t\tb = empty;\n+\n+\treturn 0 == strcmp(a, b);\n+}\n+\n+static int zero_hash_eq(uint8_t *a, uint8_t *b, int sz)\n+{\n+\tif (a == NULL)\n+\t\ta = zero;\n+\n+\tif (b == NULL)\n+\t\tb = zero;\n+\n+\treturn !memcmp(a, b, sz);\n+}\n+\n+int reftable_log_record_equal(struct reftable_log_record *a,\n+\t\t\t struct reftable_log_record *b, int hash_size)\n+{\n+\treturn null_streq(a->name, b->name) && null_streq(a->email, b->email) &&\n+\t null_streq(a->message, b->message) &&\n+\t zero_hash_eq(a->old_hash, b->old_hash, hash_size) &&\n+\t zero_hash_eq(a->new_hash, b->new_hash, hash_size) &&\n+\t a->time == b->time && a->tz_offset == b->tz_offset &&\n+\t a->update_index == b->update_index;\n+}\n+\n+static int reftable_log_record_is_deletion_void(const void *p)\n+{\n+\treturn reftable_log_record_is_deletion(\n+\t\t(const struct reftable_log_record *)p);\n+}\n+\n+struct reftable_record_vtable reftable_log_record_vtable = {\n+\t.key = &reftable_log_record_key,\n+\t.type = BLOCK_TYPE_LOG,\n+\t.copy_from = &reftable_log_record_copy_from,\n+\t.val_type = &reftable_log_record_val_type,\n+\t.encode = &reftable_log_record_encode,\n+\t.decode = &reftable_log_record_decode,\n+\t.clear = &reftable_log_record_clear_void,\n+\t.is_deletion = &reftable_log_record_is_deletion_void,\n+};\n+\n+struct reftable_record reftable_new_record(uint8_t typ)\n+{\n+\tstruct reftable_record rec = { NULL };\n+\tswitch (typ) {\n+\tcase BLOCK_TYPE_REF: {\n+\t\tstruct reftable_ref_record *r =\n+\t\t\treftable_calloc(sizeof(struct reftable_ref_record));\n+\t\treftable_record_from_ref(&rec, r);\n+\t\treturn rec;\n+\t}\n+\n+\tcase BLOCK_TYPE_OBJ: {\n+\t\tstruct reftable_obj_record *r =\n+\t\t\treftable_calloc(sizeof(struct reftable_obj_record));\n+\t\treftable_record_from_obj(&rec, r);\n+\t\treturn rec;\n+\t}\n+\tcase BLOCK_TYPE_LOG: {\n+\t\tstruct reftable_log_record *r =\n+\t\t\treftable_calloc(sizeof(struct reftable_log_record));\n+\t\treftable_record_from_log(&rec, r);\n+\t\treturn rec;\n+\t}\n+\tcase BLOCK_TYPE_INDEX: {\n+\t\tstruct reftable_index_record empty = { .last_key =\n+\t\t\t\t\t\t\t STRBUF_INIT };\n+\t\tstruct reftable_index_record *r =\n+\t\t\treftable_calloc(sizeof(struct reftable_index_record));\n+\t\t*r = empty;\n+\t\treftable_record_from_index(&rec, r);\n+\t\treturn rec;\n+\t}\n+\t}\n+\tabort();\n+\treturn rec;\n+}\n+\n+void *reftable_record_yield(struct reftable_record *rec)\n+{\n+\tvoid *p = rec->data;\n+\trec->data = NULL;\n+\treturn p;\n+}\n+\n+void reftable_record_destroy(struct reftable_record *rec)\n+{\n+\treftable_record_clear(rec);\n+\treftable_free(reftable_record_yield(rec));\n+}\n+\n+static void reftable_index_record_key(const void *r, struct strbuf *dest)\n+{\n+\tstruct reftable_index_record *rec = (struct reftable_index_record *)r;\n+\tstrbuf_reset(dest);\n+}\n+\n+static void reftable_index_record_copy_from(void *rec, const void *src_rec,\n+\t\t\t\t\t int hash_size)\n+{\n+\tstruct reftable_index_record *dst = (struct reftable_index_record *)rec;\n+\tstruct reftable_index_record *src =\n+\t\t(struct reftable_index_record *)src_rec;\n+\n+\tstrbuf_reset(&dst->last_key);\n+\tdst->offset = src->offset;\n+}\n+\n+static void reftable_index_record_clear(void *rec)\n+{\n+\tstruct reftable_index_record *idx = (struct reftable_index_record *)rec;\n+\tstrbuf_release(&idx->last_key);\n+}\n+\n+static uint8_t reftable_index_record_val_type(const void *rec)\n+{\n+\treturn 0;\n+}\n+\n+static int reftable_index_record_encode(const void *rec, struct string_view out,\n+\t\t\t\t\tint hash_size)\n+{\n+\tconst struct reftable_index_record *r =\n+\t\t(const struct reftable_index_record *)rec;\n+\tstruct string_view start = out;\n+\n+\tint n = put_var_int(&out, r->offset);\n+\tif (n < 0)\n+\t\treturn n;\n+\n+\tstring_view_consume(&out, n);\n+\n+\treturn start.len - out.len;\n+}\n+\n+static int reftable_index_record_decode(void *rec, struct strbuf key,\n+\t\t\t\t\tuint8_t val_type, struct string_view in,\n+\t\t\t\t\tint hash_size)\n+{\n+\tstruct string_view start = in;\n+\tstruct reftable_index_record *r = (struct reftable_index_record *)rec;\n+\tint n = 0;\n+\n+\tstrbuf_reset(&r->last_key);\n+\n+\tn = get_var_int(&r->offset, &in);\n+\tif (n < 0)\n+\t\treturn n;\n+\n+\tstring_view_consume(&in, n);\n+\treturn start.len - in.len;\n+}\n+\n+struct reftable_record_vtable reftable_index_record_vtable = {\n+\t.key = &reftable_index_record_key,\n+\t.type = BLOCK_TYPE_INDEX,\n+\t.copy_from = &reftable_index_record_copy_from,\n+\t.val_type = &reftable_index_record_val_type,\n+\t.encode = &reftable_index_record_encode,\n+\t.decode = &reftable_index_record_decode,\n+\t.clear = &reftable_index_record_clear,\n+\t.is_deletion = &not_a_deletion,\n+};\n+\n+void reftable_record_key(struct reftable_record *rec, struct strbuf *dest)\n+{\n+\trec->ops->key(rec->data, dest);\n+}\n+\n+uint8_t reftable_record_type(struct reftable_record *rec)\n+{\n+\treturn rec->ops->type;\n+}\n+\n+int reftable_record_encode(struct reftable_record *rec, struct string_view dest,\n+\t\t\t int hash_size)\n+{\n+\treturn rec->ops->encode(rec->data, dest, hash_size);\n+}\n+\n+void reftable_record_copy_from(struct reftable_record *rec,\n+\t\t\t struct reftable_record *src, int hash_size)\n+{\n+\tassert(src->ops->type == rec->ops->type);\n+\n+\trec->ops->copy_from(rec->data, src->data, hash_size);\n+}\n+\n+uint8_t reftable_record_val_type(struct reftable_record *rec)\n+{\n+\treturn rec->ops->val_type(rec->data);\n+}\n+\n+int reftable_record_decode(struct reftable_record *rec, struct strbuf key,\n+\t\t\t uint8_t extra, struct string_view src, int hash_size)\n+{\n+\treturn rec->ops->decode(rec->data, key, extra, src, hash_size);\n+}\n+\n+void reftable_record_clear(struct reftable_record *rec)\n+{\n+\trec->ops->clear(rec->data);\n+}\n+\n+int reftable_record_is_deletion(struct reftable_record *rec)\n+{\n+\treturn rec->ops->is_deletion(rec->data);\n+}\n+\n+void reftable_record_from_ref(struct reftable_record *rec,\n+\t\t\t struct reftable_ref_record *ref_rec)\n+{\n+\tassert(rec->ops == NULL);\n+\trec->data = ref_rec;\n+\trec->ops = &reftable_ref_record_vtable;\n+}\n+\n+void reftable_record_from_obj(struct reftable_record *rec,\n+\t\t\t struct reftable_obj_record *obj_rec)\n+{\n+\tassert(rec->ops == NULL);\n+\trec->data = obj_rec;\n+\trec->ops = &reftable_obj_record_vtable;\n+}\n+\n+void reftable_record_from_index(struct reftable_record *rec,\n+\t\t\t\tstruct reftable_index_record *index_rec)\n+{\n+\tassert(rec->ops == NULL);\n+\trec->data = index_rec;\n+\trec->ops = &reftable_index_record_vtable;\n+}\n+\n+void reftable_record_from_log(struct reftable_record *rec,\n+\t\t\t struct reftable_log_record *log_rec)\n+{\n+\tassert(rec->ops == NULL);\n+\trec->data = log_rec;\n+\trec->ops = &reftable_log_record_vtable;\n+}\n+\n+struct reftable_ref_record *reftable_record_as_ref(struct reftable_record *rec)\n+{\n+\tassert(reftable_record_type(rec) == BLOCK_TYPE_REF);\n+\treturn (struct reftable_ref_record *)rec->data;\n+}\n+\n+struct reftable_log_record *reftable_record_as_log(struct reftable_record *rec)\n+{\n+\tassert(reftable_record_type(rec) == BLOCK_TYPE_LOG);\n+\treturn (struct reftable_log_record *)rec->data;\n+}\n+\n+static int hash_equal(uint8_t *a, uint8_t *b, int hash_size)\n+{\n+\tif (a != NULL && b != NULL)\n+\t\treturn !memcmp(a, b, hash_size);\n+\n+\treturn a == b;\n+}\n+\n+static int str_equal(char *a, char *b)\n+{\n+\tif (a != NULL && b != NULL)\n+\t\treturn 0 == strcmp(a, b);\n+\n+\treturn a == b;\n+}\n+\n+int reftable_ref_record_equal(struct reftable_ref_record *a,\n+\t\t\t struct reftable_ref_record *b, int hash_size)\n+{\n+\tassert(hash_size > 0);\n+\treturn 0 == strcmp(a->refname, b->refname) &&\n+\t a->update_index == b->update_index &&\n+\t hash_equal(a->value, b->value, hash_size) &&\n+\t hash_equal(a->target_value, b->target_value, hash_size) &&\n+\t str_equal(a->target, b->target);\n+}\n+\n+int reftable_ref_record_compare_name(const void *a, const void *b)\n+{\n+\treturn strcmp(((struct reftable_ref_record *)a)->refname,\n+\t\t ((struct reftable_ref_record *)b)->refname);\n+}\n+\n+int reftable_ref_record_is_deletion(const struct reftable_ref_record *ref)\n+{\n+\treturn ref->value == NULL && ref->target == NULL &&\n+\t ref->target_value == NULL;\n+}\n+\n+int reftable_log_record_compare_key(const void *a, const void *b)\n+{\n+\tstruct reftable_log_record *la = (struct reftable_log_record *)a;\n+\tstruct reftable_log_record *lb = (struct reftable_log_record *)b;\n+\n+\tint cmp = strcmp(la->refname, lb->refname);\n+\tif (cmp)\n+\t\treturn cmp;\n+\tif (la->update_index > lb->update_index)\n+\t\treturn -1;\n+\treturn (la->update_index < lb->update_index) ? 1 : 0;\n+}\n+\n+int reftable_log_record_is_deletion(const struct reftable_log_record *log)\n+{\n+\treturn (log->new_hash == NULL && log->old_hash == NULL &&\n+\t\tlog->name == NULL && log->email == NULL &&\n+\t\tlog->message == NULL && log->time == 0 && log->tz_offset == 0 &&\n+\t\tlog->message == NULL);\n+}\n+\n+void string_view_consume(struct string_view *s, int n)\n+{\n+\ts->buf += n;\n+\ts->len -= n;\n+}\ndiff --git a/reftable/record.h b/reftable/record.h\nnew file mode 100644\nindex 0000000000..0c4725cd3c\n--- /dev/null\n+++ b/reftable/record.h\n@@ -0,0 +1,143 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#ifndef RECORD_H\n+#define RECORD_H\n+\n+#include \"reftable.h\"\n+#include \"strbuf.h\"\n+#include \"system.h\"\n+\n+/*\n+ A substring of existing string data. This structure takes no responsibility\n+ for the lifetime of the data it points to.\n+*/\n+struct string_view {\n+\tuint8_t *buf;\n+\tsize_t len;\n+};\n+\n+/* Advance `s.buf` by `n`, and decrease length. */\n+void string_view_consume(struct string_view *s, int n);\n+\n+/* utilities for de/encoding varints */\n+\n+int get_var_int(uint64_t *dest, struct string_view *in);\n+int put_var_int(struct string_view *dest, uint64_t val);\n+\n+/* Methods for records. */\n+struct reftable_record_vtable {\n+\t/* encode the key of to a uint8_t strbuf. */\n+\tvoid (*key)(const void *rec, struct strbuf *dest);\n+\n+\t/* The record type of ('r' for ref). */\n+\tuint8_t type;\n+\n+\tvoid (*copy_from)(void *dest, const void *src, int hash_size);\n+\n+\t/* a value of [0..7], indicating record subvariants (eg. ref vs. symref\n+\t * vs ref deletion) */\n+\tuint8_t (*val_type)(const void *rec);\n+\n+\t/* encodes rec into dest, returning how much space was used. */\n+\tint (*encode)(const void *rec, struct string_view dest, int hash_size);\n+\n+\t/* decode data from `src` into the record. */\n+\tint (*decode)(void *rec, struct strbuf key, uint8_t extra,\n+\t\t struct string_view src, int hash_size);\n+\n+\t/* deallocate and null the record. */\n+\tvoid (*clear)(void *rec);\n+\n+\t/* is this a tombstone? */\n+\tint (*is_deletion)(const void *rec);\n+};\n+\n+/* record is a generic wrapper for different types of records. */\n+struct reftable_record {\n+\tvoid *data;\n+\tstruct reftable_record_vtable *ops;\n+};\n+\n+/* returns true for recognized block types. Block start with the block type. */\n+int reftable_is_block_type(uint8_t typ);\n+\n+/* creates a malloced record of the given type. Dispose with record_destroy */\n+struct reftable_record reftable_new_record(uint8_t typ);\n+\n+extern struct reftable_record_vtable reftable_ref_record_vtable;\n+\n+/* Encode `key` into `dest`. Sets `is_restart` to indicate a restart. Returns\n+ number of bytes written. */\n+int reftable_encode_key(int *is_restart, struct string_view dest,\n+\t\t\tstruct strbuf prev_key, struct strbuf key,\n+\t\t\tuint8_t extra);\n+\n+/* Decode into `key` and `extra` from `in` */\n+int reftable_decode_key(struct strbuf *key, uint8_t *extra,\n+\t\t\tstruct strbuf last_key, struct string_view in);\n+\n+/* reftable_index_record are used internally to speed up lookups. */\n+struct reftable_index_record {\n+\tuint64_t offset; /* Offset of block */\n+\tstruct strbuf last_key; /* Last key of the block. */\n+};\n+\n+/* reftable_obj_record stores an object ID => ref mapping. */\n+struct reftable_obj_record {\n+\tuint8_t *hash_prefix; /* leading bytes of the object ID */\n+\tint hash_prefix_len; /* number of leading bytes. Constant\n+\t\t\t * across a single table. */\n+\tuint64_t *offsets; /* a vector of file offsets. */\n+\tint offset_len;\n+};\n+\n+/* see struct record_vtable */\n+\n+void reftable_record_key(struct reftable_record *rec, struct strbuf *dest);\n+uint8_t reftable_record_type(struct reftable_record *rec);\n+void reftable_record_copy_from(struct reftable_record *rec,\n+\t\t\t struct reftable_record *src, int hash_size);\n+uint8_t reftable_record_val_type(struct reftable_record *rec);\n+int reftable_record_encode(struct reftable_record *rec, struct string_view dest,\n+\t\t\t int hash_size);\n+int reftable_record_decode(struct reftable_record *rec, struct strbuf key,\n+\t\t\t uint8_t extra, struct string_view src,\n+\t\t\t int hash_size);\n+int reftable_record_is_deletion(struct reftable_record *rec);\n+\n+/* zeroes out the embedded record */\n+void reftable_record_clear(struct reftable_record *rec);\n+\n+/* clear out the record, yielding the reftable_record data that was\n+ * encapsulated. */\n+void *reftable_record_yield(struct reftable_record *rec);\n+\n+/* clear and deallocate embedded record, and zero `rec`. */\n+void reftable_record_destroy(struct reftable_record *rec);\n+\n+/* initialize generic records from concrete records. The generic record should\n+ * be zeroed out. */\n+void reftable_record_from_obj(struct reftable_record *rec,\n+\t\t\t struct reftable_obj_record *objrec);\n+void reftable_record_from_index(struct reftable_record *rec,\n+\t\t\t\tstruct reftable_index_record *idxrec);\n+void reftable_record_from_ref(struct reftable_record *rec,\n+\t\t\t struct reftable_ref_record *refrec);\n+void reftable_record_from_log(struct reftable_record *rec,\n+\t\t\t struct reftable_log_record *logrec);\n+struct reftable_ref_record *reftable_record_as_ref(struct reftable_record *ref);\n+struct reftable_log_record *reftable_record_as_log(struct reftable_record *ref);\n+\n+/* for qsort. */\n+int reftable_ref_record_compare_name(const void *a, const void *b);\n+\n+/* for qsort. */\n+int reftable_log_record_compare_key(const void *a, const void *b);\n+\n+#endif\ndiff --git a/reftable/record_test.c b/reftable/record_test.c\nnew file mode 100644\nindex 0000000000..6da80d33cf\n--- /dev/null\n+++ b/reftable/record_test.c\n@@ -0,0 +1,410 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"record.h\"\n+\n+#include \"system.h\"\n+#include \"basics.h\"\n+#include \"constants.h\"\n+#include \"reftable.h\"\n+#include \"test_framework.h\"\n+#include \"reftable-tests.h\"\n+\n+static void test_copy(struct reftable_record *rec)\n+{\n+\tstruct reftable_record copy =\n+\t\treftable_new_record(reftable_record_type(rec));\n+\treftable_record_copy_from(&copy, rec, SHA1_SIZE);\n+\t/* do it twice to catch memory leaks */\n+\treftable_record_copy_from(&copy, rec, SHA1_SIZE);\n+\tswitch (reftable_record_type(&copy)) {\n+\tcase BLOCK_TYPE_REF:\n+\t\tassert(reftable_ref_record_equal(reftable_record_as_ref(&copy),\n+\t\t\t\t\t\t reftable_record_as_ref(rec),\n+\t\t\t\t\t\t SHA1_SIZE));\n+\t\tbreak;\n+\tcase BLOCK_TYPE_LOG:\n+\t\tassert(reftable_log_record_equal(reftable_record_as_log(&copy),\n+\t\t\t\t\t\t reftable_record_as_log(rec),\n+\t\t\t\t\t\t SHA1_SIZE));\n+\t\tbreak;\n+\t}\n+\treftable_record_destroy(&copy);\n+}\n+\n+static void test_varint_roundtrip(void)\n+{\n+\tuint64_t inputs[] = { 0,\n+\t\t\t 1,\n+\t\t\t 27,\n+\t\t\t 127,\n+\t\t\t 128,\n+\t\t\t 257,\n+\t\t\t 4096,\n+\t\t\t ((uint64_t)1 << 63),\n+\t\t\t ((uint64_t)1 << 63) + ((uint64_t)1 << 63) - 1 };\n+\tint i = 0;\n+\tfor (i = 0; i < ARRAY_SIZE(inputs); i++) {\n+\t\tuint8_t dest;\n+\n+\t\tstruct string_view out = {\n+\t\t\t.buf = dest,\n+\t\t\t.len = sizeof(dest),\n+\t\t};\n+\t\tuint64_t in = inputs[i];\n+\t\tint n = put_var_int(&out, in);\n+\t\tuint64_t got = 0;\n+\n+\t\tassert(n > 0);\n+\t\tout.len = n;\n+\t\tn = get_var_int(&got, &out);\n+\t\tassert(n > 0);\n+\n+\t\tassert(got == in);\n+\t}\n+}\n+\n+static void test_common_prefix(void)\n+{\n+\tstruct {\n+\t\tconst char *a, *b;\n+\t\tint want;\n+\t} cases[] = {\n+\t\t{ \"abc\", \"ab\", 2 },\n+\t\t{ \"\", \"abc\", 0 },\n+\t\t{ \"abc\", \"abd\", 2 },\n+\t\t{ \"abc\", \"pqr\", 0 },\n+\t};\n+\n+\tint i = 0;\n+\tfor (i = 0; i < ARRAY_SIZE(cases); i++) {\n+\t\tstruct strbuf a = STRBUF_INIT;\n+\t\tstruct strbuf b = STRBUF_INIT;\n+\t\tassert(common_prefix_size(&a, &b) == cases[i].want);\n+\n+\t\tstrbuf_release(&a);\n+\t\tstrbuf_release(&b);\n+\t}\n+}\n+\n+static void set_hash(uint8_t *h, int j)\n+{\n+\tint i = 0;\n+\tfor (i = 0; i < hash_size(SHA1_ID); i++) {\n+\t\th[i] = (j >> i) & 0xff;\n+\t}\n+}\n+\n+static void test_reftable_ref_record_roundtrip(void)\n+{\n+\tint i = 0;\n+\n+\tfor (i = 0; i <= 3; i++) {\n+\t\tstruct reftable_ref_record in = { 0 };\n+\t\tstruct reftable_ref_record out = {\n+\t\t\t.refname = xstrdup(\"old name\"),\n+\t\t\t.value = reftable_calloc(SHA1_SIZE),\n+\t\t\t.target_value = reftable_calloc(SHA1_SIZE),\n+\t\t\t.target = xstrdup(\"old value\"),\n+\t\t};\n+\t\tstruct reftable_record rec_out = { 0 };\n+\t\tstruct strbuf key = STRBUF_INIT;\n+\t\tstruct reftable_record rec = { 0 };\n+\t\tuint8_t buffer = { 0 };\n+\t\tstruct string_view dest = {\n+\t\t\t.buf = buffer,\n+\t\t\t.len = sizeof(buffer),\n+\t\t};\n+\n+\t\tint n, m;\n+\n+\t\tswitch (i) {\n+\t\tcase 0:\n+\t\t\tbreak;\n+\t\tcase 1:\n+\t\t\tin.value = reftable_malloc(SHA1_SIZE);\n+\t\t\tset_hash(in.value, 1);\n+\t\t\tbreak;\n+\t\tcase 2:\n+\t\t\tin.value = reftable_malloc(SHA1_SIZE);\n+\t\t\tset_hash(in.value, 1);\n+\t\t\tin.target_value = reftable_malloc(SHA1_SIZE);\n+\t\t\tset_hash(in.target_value, 2);\n+\t\t\tbreak;\n+\t\tcase 3:\n+\t\t\tin.target = xstrdup(\"target\");\n+\t\t\tbreak;\n+\t\t}\n+\n+\t\treftable_record_from_ref(&rec, &in);\n+\t\ttest_copy(&rec);\n+\n+\t\tassert(reftable_record_val_type(&rec) == i);\n+\n+\t\treftable_record_key(&rec, &key);\n+\t\tn = reftable_record_encode(&rec, dest, SHA1_SIZE);\n+\t\tassert(n > 0);\n+\n+\t\t/* decode into a non-zero reftable_record to test for leaks. */\n+\n+\t\treftable_record_from_ref(&rec_out, &out);\n+\t\tm = reftable_record_decode(&rec_out, key, i, dest, SHA1_SIZE);\n+\t\tassert(n == m);\n+\n+\t\tassert((out.value != NULL) == (in.value != NULL));\n+\t\tassert((out.target_value != NULL) == (in.target_value != NULL));\n+\t\tassert((out.target != NULL) == (in.target != NULL));\n+\t\treftable_record_clear(&rec_out);\n+\n+\t\tstrbuf_release(&key);\n+\t\treftable_ref_record_clear(&in);\n+\t}\n+}\n+\n+static void test_reftable_log_record_equal(void)\n+{\n+\tstruct reftable_log_record in = {\n+\t\t{\n+\t\t\t.update_index = 42,\n+\t\t},\n+\t\t{\n+\t\t\t.update_index = 22,\n+\t\t}\n+\t};\n+\n+\tassert(!reftable_log_record_equal(&in, &in, SHA1_SIZE));\n+\tin.update_index = in.update_index;\n+\tassert(reftable_log_record_equal(&in, &in, SHA1_SIZE));\n+\treftable_log_record_clear(&in);\n+\treftable_log_record_clear(&in);\n+}\n+\n+static void test_reftable_log_record_roundtrip(void)\n+{\n+\tstruct reftable_log_record in = {\n+\t\t{\n+\t\t\t.old_hash = reftable_malloc(SHA1_SIZE),\n+\t\t\t.new_hash = reftable_malloc(SHA1_SIZE),\n+\t\t\t.name = xstrdup(\"han-wen\"),\n+\t\t\t.message = xstrdup(\"test\"),\n+\t\t\t.update_index = 42,\n+\t\t\t.time = 1577123507,\n+\t\t\t.tz_offset = 100,\n+\t\t},\n+\t\t{\n+\t\t\t.update_index = 22,\n+\t\t}\n+\t};\n+\tset_test_hash(in.new_hash, 1);\n+\tset_test_hash(in.old_hash, 2);\n+\tfor (int i = 0; i < ARRAY_SIZE(in); i++) {\n+\t\tstruct reftable_record rec = { 0 };\n+\t\tstruct strbuf key = STRBUF_INIT;\n+\t\tuint8_t buffer = { 0 };\n+\t\tstruct string_view dest = {\n+\t\t\t.buf = buffer,\n+\t\t\t.len = sizeof(buffer),\n+\t\t};\n+\t\t/* populate out, to check for leaks. */\n+\t\tstruct reftable_log_record out = {\n+\t\t\t.refname = xstrdup(\"old name\"),\n+\t\t\t.new_hash = reftable_calloc(SHA1_SIZE),\n+\t\t\t.old_hash = reftable_calloc(SHA1_SIZE),\n+\t\t\t.name = xstrdup(\"old name\"),\n+\t\t\t.email = xstrdup(\"old@email\"),\n+\t\t\t.message = xstrdup(\"old message\"),\n+\t\t};\n+\t\tstruct reftable_record rec_out = { 0 };\n+\t\tint n, m, valtype;\n+\n+\t\treftable_record_from_log(&rec, &in[i]);\n+\n+\t\ttest_copy(&rec);\n+\n+\t\treftable_record_key(&rec, &key);\n+\n+\t\tn = reftable_record_encode(&rec, dest, SHA1_SIZE);\n+\t\tassert(n >= 0);\n+\t\treftable_record_from_log(&rec_out, &out);\n+\t\tvaltype = reftable_record_val_type(&rec);\n+\t\tm = reftable_record_decode(&rec_out, key, valtype, dest,\n+\t\t\t\t\t SHA1_SIZE);\n+\t\tassert(n == m);\n+\n+\t\tassert(reftable_log_record_equal(&in[i], &out, SHA1_SIZE));\n+\t\treftable_log_record_clear(&in[i]);\n+\t\tstrbuf_release(&key);\n+\t\treftable_record_clear(&rec_out);\n+\t}\n+}\n+\n+static void test_u24_roundtrip(void)\n+{\n+\tuint32_t in = 0x112233;\n+\tuint8_t dest;\n+\tuint32_t out;\n+\tput_be24(dest, in);\n+\tout = get_be24(dest);\n+\tassert(in == out);\n+}\n+\n+static void test_key_roundtrip(void)\n+{\n+\tuint8_t buffer = { 0 };\n+\tstruct string_view dest = {\n+\t\t.buf = buffer,\n+\t\t.len = sizeof(buffer),\n+\t};\n+\tstruct strbuf last_key = STRBUF_INIT;\n+\tstruct strbuf key = STRBUF_INIT;\n+\tstruct strbuf roundtrip = STRBUF_INIT;\n+\tint restart;\n+\tuint8_t extra;\n+\tint n, m;\n+\tuint8_t rt_extra;\n+\n+\textra = 6;\n+\tn = reftable_encode_key(&restart, dest, last_key, key, extra);\n+\tassert(!restart);\n+\tassert(n > 0);\n+\n+\tm = reftable_decode_key(&roundtrip, &rt_extra, last_key, dest);\n+\tassert(n == m);\n+\tassert(0 == strbuf_cmp(&key, &roundtrip));\n+\tassert(rt_extra == extra);\n+\n+\tstrbuf_release(&last_key);\n+\tstrbuf_release(&key);\n+\tstrbuf_release(&roundtrip);\n+}\n+\n+static void test_reftable_obj_record_roundtrip(void)\n+{\n+\tuint8_t testHash1[SHA1_SIZE] = { 1, 2, 3, 4, 0 };\n+\tuint64_t till9[] = { 1, 2, 3, 4, 500, 600, 700, 800, 9000 };\n+\tstruct reftable_obj_record recs = { {\n+\t\t\t\t\t\t .hash_prefix = testHash1,\n+\t\t\t\t\t\t .hash_prefix_len = 5,\n+\t\t\t\t\t\t .offsets = till9,\n+\t\t\t\t\t\t .offset_len = 3,\n+\t\t\t\t\t },\n+\t\t\t\t\t {\n+\t\t\t\t\t\t .hash_prefix = testHash1,\n+\t\t\t\t\t\t .hash_prefix_len = 5,\n+\t\t\t\t\t\t .offsets = till9,\n+\t\t\t\t\t\t .offset_len = 9,\n+\t\t\t\t\t },\n+\t\t\t\t\t {\n+\t\t\t\t\t\t .hash_prefix = testHash1,\n+\t\t\t\t\t\t .hash_prefix_len = 5,\n+\t\t\t\t\t } };\n+\tint i = 0;\n+\tfor (i = 0; i < ARRAY_SIZE(recs); i++) {\n+\t\tstruct reftable_obj_record in = recs[i];\n+\t\tuint8_t buffer = { 0 };\n+\t\tstruct string_view dest = {\n+\t\t\t.buf = buffer,\n+\t\t\t.len = sizeof(buffer),\n+\t\t};\n+\t\tstruct reftable_record rec = { 0 };\n+\t\tstruct strbuf key = STRBUF_INIT;\n+\t\tstruct reftable_obj_record out = { 0 };\n+\t\tstruct reftable_record rec_out = { 0 };\n+\t\tint n, m;\n+\t\tuint8_t extra;\n+\n+\t\treftable_record_from_obj(&rec, &in);\n+\t\ttest_copy(&rec);\n+\t\treftable_record_key(&rec, &key);\n+\t\tn = reftable_record_encode(&rec, dest, SHA1_SIZE);\n+\t\tassert(n > 0);\n+\t\textra = reftable_record_val_type(&rec);\n+\t\treftable_record_from_obj(&rec_out, &out);\n+\t\tm = reftable_record_decode(&rec_out, key, extra, dest,\n+\t\t\t\t\t SHA1_SIZE);\n+\t\tassert(n == m);\n+\n+\t\tassert(in.hash_prefix_len == out.hash_prefix_len);\n+\t\tassert(in.offset_len == out.offset_len);\n+\n+\t\tassert(!memcmp(in.hash_prefix, out.hash_prefix,\n+\t\t\t in.hash_prefix_len));\n+\t\tassert(0 == memcmp(in.offsets, out.offsets,\n+\t\t\t\t sizeof(uint64_t) * in.offset_len));\n+\t\tstrbuf_release(&key);\n+\t\treftable_record_clear(&rec_out);\n+\t}\n+}\n+\n+static void test_reftable_index_record_roundtrip(void)\n+{\n+\tstruct reftable_index_record in = {\n+\t\t.offset = 42,\n+\t\t.last_key = STRBUF_INIT,\n+\t};\n+\tuint8_t buffer = { 0 };\n+\tstruct string_view dest = {\n+\t\t.buf = buffer,\n+\t\t.len = sizeof(buffer),\n+\t};\n+\tstruct strbuf key = STRBUF_INIT;\n+\tstruct reftable_record rec = { 0 };\n+\tstruct reftable_index_record out = { .last_key = STRBUF_INIT };\n+\tstruct reftable_record out_rec = { NULL };\n+\tint n, m;\n+\tuint8_t extra;\n+\n+\treftable_record_from_index(&rec, &in);\n+\treftable_record_key(&rec, &key);\n+\ttest_copy(&rec);\n+\n+\tassert(0 == strbuf_cmp(&key, &in.last_key));\n+\tn = reftable_record_encode(&rec, dest, SHA1_SIZE);\n+\tassert(n > 0);\n+\n+\textra = reftable_record_val_type(&rec);\n+\treftable_record_from_index(&out_rec, &out);\n+\tm = reftable_record_decode(&out_rec, key, extra, dest, SHA1_SIZE);\n+\tassert(m == n);\n+\n+\tassert(in.offset == out.offset);\n+\n+\treftable_record_clear(&out_rec);\n+\tstrbuf_release(&key);\n+\tstrbuf_release(&in.last_key);\n+}\n+\n+int record_test_main(int argc, const char *argv[])\n+{\n+\t\t &test_reftable_log_record_equal);\n+\t\t &test_reftable_log_record_roundtrip);\n+\t\t &test_reftable_ref_record_roundtrip);\n+\t\t &test_reftable_obj_record_roundtrip);\n+\t\t &test_reftable_index_record_roundtrip);\n+\treturn test_main(argc, argv);\n+}\ndiff --git a/t/helper/test-reftable.c b/t/helper/test-reftable.c\nindex 7d50aa6bcc..9341272089 100644\n--- a/t/helper/test-reftable.c\n+++ b/t/helper/test-reftable.c\n@@ -3,6 +3,7 @@\n\nint cmd__reftable(int argc, const char **argv)\n{\n+\trecord_test_main(argc, argv);\nstrbuf_test_main(argc, argv);\nreturn 0;\n}\n--\n\n• ```* Re: [PATCH 06/13] reftable: (de)serialization for the polymorphic record type.\n2020-09-16 19:10 ` [PATCH 06/13] reftable: (de)serialization for the polymorphic record type Han-Wen Nienhuys via GitGitGadget\n@ 2020-09-20 1:00 ` Junio C Hamano\n2020-09-21 13:13 ` Han-Wen Nienhuys\nFrom: Junio C Hamano @ 2020-09-20 1:00 UTC (permalink / raw)\nTo: Han-Wen Nienhuys via GitGitGadget; +Cc: git, Han-Wen Nienhuys, Han-Wen Nienhuys\n\n> +static void reftable_log_record_key(const void *r, struct strbuf *dest)\n> +{\n> +\tconst struct reftable_log_record *rec =\n> +\t\t(const struct reftable_log_record *)r;\n> +\tint len = strlen(rec->refname);\n> +\tuint8_t i64;\n> +\tuint64_t ts = 0;\n> +\tstrbuf_reset(dest);\n> +\tstrbuf_add(dest, (uint8_t *)rec->refname, len + 1);\n> +\n> +\tts = (~ts) - rec->update_index;\n> +\tput_be64(&i64, ts);\n> +}\n\nWe seem to be getting\n\nreftable/record.c: In function 'reftable_log_record_key':\nreftable/record.c:578:2: error: dereferencing type-punned pointer will break strict-aliasing rules [-Werror=strict-aliasing]\nput_be64(&i64, ts);\n^\nCC reftable/refname.o\n\nwhen this series is merged to 'seen'.\n\ncf. e.g. https://travis-ci.org/github/git/git/jobs/728655368\n\nThanks.\n\n• ```* Re: [PATCH 06/13] reftable: (de)serialization for the polymorphic record type.\n2020-09-20 1:00 ` Junio C Hamano\n@ 2020-09-21 13:13 ` Han-Wen Nienhuys\n2020-09-24 7:21 ` Jeff King\nFrom: Han-Wen Nienhuys @ 2020-09-21 13:13 UTC (permalink / raw)\nTo: Junio C Hamano; +Cc: Han-Wen Nienhuys via GitGitGadget, git, Han-Wen Nienhuys\n\nOn Sun, Sep 20, 2020 at 3:00 AM Junio C Hamano <[email protected]> wrote:\n> > +static void reftable_log_record_key(const void *r, struct strbuf *dest)\n> > +{\n> > + const struct reftable_log_record *rec =\n> > + (const struct reftable_log_record *)r;\n> > + int len = strlen(rec->refname);\n> > + uint8_t i64;\n> > + uint64_t ts = 0;\n> > + strbuf_reset(dest);\n> > + strbuf_add(dest, (uint8_t *)rec->refname, len + 1);\n> > +\n> > + ts = (~ts) - rec->update_index;\n> > + put_be64(&i64, ts);\n> > + strbuf_add(dest, i64, sizeof(i64));\n> > +}\n>\n> We seem to be getting\n>\n> reftable/record.c: In function 'reftable_log_record_key':\n> reftable/record.c:578:2: error: dereferencing type-punned pointer will break strict-aliasing rules [-Werror=strict-aliasing]\n> put_be64(&i64, ts);\n> ^\n> CC reftable/refname.o\n>\n> when this series is merged to 'seen'.\n\nThanks for bringing this up. I did see this before, but I've been\nunable to reproduce this locally, and I forgot about it.\n\nThe problem is actually triggered by the Git-provided put_be64()\n(which appears unused in the Git source code). The definition\n\n#define put_be64(p, v) do { *(uint64_t *)(p) = htonll(v); } while (0)\n\nis trying to reinterpret a char* as a uint64_t* , which is illegal in\nstrict aliasing rules? I originally had\n\n+void put_be64(uint8_t *out, uint64_t v)\n+{\n+ int i = sizeof(uint64_t);\n+ while (i--) {\n+ out[i] = (uint8_t)(v & 0xff);\n+ v >>= 8;\n+ }\n+}\n\nin my reftable library, which is portable. Is there a reason for the\nmagic with htonll and friends?\n\n--\nI work 80%. Don't expect answers from me on Fridays.\n--\nGoogle Germany GmbH, Erika-Mann-Strasse 33, 80636 Munich\nRegistergericht und -nummer: Hamburg, HRB 86891\nSitz der Gesellschaft: Hamburg\nGeschäftsführer: Paul Manicle, Halimah DeLaine Prado\n\n• ```* Re: [PATCH 06/13] reftable: (de)serialization for the polymorphic record type.\n2020-09-21 13:13 ` Han-Wen Nienhuys\n@ 2020-09-24 7:21 ` Jeff King\n2020-09-24 7:31 ` Jeff King\nFrom: Jeff King @ 2020-09-24 7:21 UTC (permalink / raw)\nTo: Han-Wen Nienhuys\nCc: Junio C Hamano, Han-Wen Nienhuys via GitGitGadget, git, Han-Wen Nienhuys\n\nOn Mon, Sep 21, 2020 at 03:13:05PM +0200, Han-Wen Nienhuys wrote:\n\n> The problem is actually triggered by the Git-provided put_be64()\n> (which appears unused in the Git source code). The definition\n>\n> #define put_be64(p, v) do { *(uint64_t *)(p) = htonll(v); } while (0)\n>\n> is trying to reinterpret a char* as a uint64_t* , which is illegal in\n> strict aliasing rules?\n\nAh, thanks for finding that. I think this resolves the mystery I had\naround aliasing warnings with put_be32() in f39ad38410 (fast-export: use\nlocal array to store anonymized oid, 2020-06-25). I got confused because\nwhen I looked at the implementation of put_be32(), I stupidly looked at\nthe NO_ALIGNED_LOADS fallback code, which indeed does not alias. But the\none we use on x86 does.\n\nI thought this would be OK because C allows aliasing through \"char *\"\npointers. But I think it may only go the other way. I.e., you can\ntype-pun a uint64_t as a char, but not the other way around. But then\nwhy doesn't basically every use of put_be32() and put_be64() complain?\n\n>\n> +void put_be64(uint8_t *out, uint64_t v)\n> +{\n> + int i = sizeof(uint64_t);\n> + while (i--) {\n> + out[i] = (uint8_t)(v & 0xff);\n> + v >>= 8;\n> + }\n> +}\n>\n> in my reftable library, which is portable. Is there a reason for the\n> magic with htonll and friends?\n\nPresumably it was thought to be faster. This comes originally from the\nblock-sha1 code in 660231aa97 (block-sha1: support for architectures\nwith memory alignment restrictions, 2009-08-12). I don't know how it\ncompares in practice, and especially these days.\n\nOur fallback routines are similar to an unrolled version of what you\nwrote above.\n\n-Peff\n\n• ```* Re: [PATCH 06/13] reftable: (de)serialization for the polymorphic record type.\n2020-09-24 7:21 ` Jeff King\n@ 2020-09-24 7:31 ` Jeff King\n2020-09-24 17:22 ` Junio C Hamano\nFrom: Jeff King @ 2020-09-24 7:31 UTC (permalink / raw)\nTo: Han-Wen Nienhuys\nCc: Junio C Hamano, Han-Wen Nienhuys via GitGitGadget, git, Han-Wen Nienhuys\n\nOn Thu, Sep 24, 2020 at 03:21:51AM -0400, Jeff King wrote:\n\n> >\n> > +void put_be64(uint8_t *out, uint64_t v)\n> > +{\n> > + int i = sizeof(uint64_t);\n> > + while (i--) {\n> > + out[i] = (uint8_t)(v & 0xff);\n> > + v >>= 8;\n> > + }\n> > +}\n> >\n> > in my reftable library, which is portable. Is there a reason for the\n> > magic with htonll and friends?\n>\n> Presumably it was thought to be faster. This comes originally from the\n> block-sha1 code in 660231aa97 (block-sha1: support for architectures\n> with memory alignment restrictions, 2009-08-12). I don't know how it\n> compares in practice, and especially these days.\n>\n> Our fallback routines are similar to an unrolled version of what you\n> wrote above.\n\nWe should be able to measure it pretty easily, since block-sha1 uses a\nlot of get_be32/put_be32. I generated a 4GB random file, built with\nBLK_SHA1=Yes and -O2, and timed:\n\nt/helper/test-tool sha1 <foo.rand\n\nThen I did the same, but building with -DNO_UNALIGNED_LOADS. The latter\nactually ran faster, by a small margin. Here are the hyperfine results:\n\n[stock]\nTime (mean ± σ): 6.638 s ± 0.081 s [User: 6.269 s, System: 0.368 s]\nRange (min … max): 6.550 s … 6.841 s 10 runs\n\nTime (mean ± σ): 6.418 s ± 0.015 s [User: 6.058 s, System: 0.360 s]\nRange (min … max): 6.394 s … 6.447 s 10 runs\n\nFor casual use as in reftables I doubt the difference is even\nmeasurable. But this result implies that perhaps we ought to just be\nusing the fallback version all the time.\n\n-Peff\n\n• ```* Re: [PATCH 06/13] reftable: (de)serialization for the polymorphic record type.\n2020-09-24 7:31 ` Jeff King\n@ 2020-09-24 17:22 ` Junio C Hamano\n0 siblings, 0 replies; 251+ messages in thread\nFrom: Junio C Hamano @ 2020-09-24 17:22 UTC (permalink / raw)\nTo: Jeff King\nCc: Han-Wen Nienhuys, Han-Wen Nienhuys via GitGitGadget, git,\nHan-Wen Nienhuys\n\nJeff King <[email protected]> writes:\n\n> Then I did the same, but building with -DNO_UNALIGNED_LOADS. The latter\n> actually ran faster, by a small margin. Here are the hyperfine results:\n>\n> [stock]\n> Time (mean ± σ): 6.638 s ± 0.081 s [User: 6.269 s, System: 0.368 s]\n> Range (min … max): 6.550 s … 6.841 s 10 runs\n>\n> Time (mean ± σ): 6.418 s ± 0.015 s [User: 6.058 s, System: 0.360 s]\n> Range (min … max): 6.394 s … 6.447 s 10 runs\n>\n> For casual use as in reftables I doubt the difference is even\n> measurable. But this result implies that perhaps we ought to just be\n> using the fallback version all the time.\n\nI like that one. One less configurable knob that makes us execute\ndifferent codepaths is one less thing to be worried about.\n\n• ```* [PATCH 07/13] reftable: reading/writing blocks\n2020-09-16 19:10 [PATCH 00/13] reftable library Han-Wen Nienhuys via GitGitGadget\n` (5 preceding siblings ...)\n2020-09-16 19:10 ` [PATCH 06/13] reftable: (de)serialization for the polymorphic record type Han-Wen Nienhuys via GitGitGadget\n@ 2020-09-16 19:10 ` Han-Wen Nienhuys via GitGitGadget\n2020-09-16 19:10 ` [PATCH 08/13] reftable: a generic binary tree implementation Han-Wen Nienhuys via GitGitGadget\n` (6 subsequent siblings)\n13 siblings, 0 replies; 251+ messages in thread\nFrom: Han-Wen Nienhuys via GitGitGadget @ 2020-09-16 19:10 UTC (permalink / raw)\nTo: git; +Cc: Han-Wen Nienhuys, Han-Wen Nienhuys\n\nIncludes a code snippet copied from zlib\n\n---\nMakefile | 3 +\nreftable/.gitattributes | 1 +\nreftable/block.c | 443 +++++++++++++++++++++++++++++++++++++++\nreftable/block.h | 129 ++++++++++++\nreftable/block_test.c | 158 ++++++++++++++\nreftable/zlib-compat.c | 92 ++++++++\nt/helper/test-reftable.c | 1 +\n7 files changed, 827 insertions(+)\ncreate mode 100644 reftable/.gitattributes\ncreate mode 100644 reftable/block.c\ncreate mode 100644 reftable/block.h\ncreate mode 100644 reftable/block_test.c\ncreate mode 100644 reftable/zlib-compat.c\n\ndiff --git a/Makefile b/Makefile\nindex 0fb0048c34..a897818a7e 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -2345,12 +2345,15 @@ XDIFF_OBJS += xdiff/xprepare.o\nXDIFF_OBJS += xdiff/xutils.o\n\nREFTABLE_OBJS += reftable/basics.o\n+REFTABLE_OBJS += reftable/block.o\nREFTABLE_OBJS += reftable/blocksource.o\nREFTABLE_OBJS += reftable/publicbasics.o\nREFTABLE_OBJS += reftable/compat.o\nREFTABLE_OBJS += reftable/record.o\nREFTABLE_OBJS += reftable/strbuf.o\n+REFTABLE_OBJS += reftable/zlib-compat.o\n\n+REFTABLE_TEST_OBJS += reftable/block_test.o\nREFTABLE_TEST_OBJS += reftable/record_test.o\nREFTABLE_TEST_OBJS += reftable/strbuf_test.o\nREFTABLE_TEST_OBJS += reftable/test_framework.o\ndiff --git a/reftable/.gitattributes b/reftable/.gitattributes\nnew file mode 100644\nindex 0000000000..f44451a379\n--- /dev/null\n+++ b/reftable/.gitattributes\n@@ -0,0 +1 @@\n+/zlib-compat.c\twhitespace=-indent-with-non-tab,-trailing-space\ndiff --git a/reftable/block.c b/reftable/block.c\nnew file mode 100644\nindex 0000000000..d61faa0fd4\n--- /dev/null\n+++ b/reftable/block.c\n@@ -0,0 +1,443 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"block.h\"\n+\n+#include \"blocksource.h\"\n+#include \"constants.h\"\n+#include \"record.h\"\n+#include \"reftable.h\"\n+#include \"system.h\"\n+#include \"zlib.h\"\n+\n+{\n+\tswitch (version) {\n+\tcase 1:\n+\t\treturn 24;\n+\tcase 2:\n+\t\treturn 28;\n+\t}\n+\tabort();\n+}\n+\n+int footer_size(int version)\n+{\n+\tswitch (version) {\n+\tcase 1:\n+\t\treturn 68;\n+\tcase 2:\n+\t\treturn 72;\n+\t}\n+\tabort();\n+}\n+\n+int block_writer_register_restart(struct block_writer *w, int n, int restart,\n+\t\t\t\t struct strbuf *key);\n+\n+void block_writer_init(struct block_writer *bw, uint8_t typ, uint8_t *buf,\n+\t\t uint32_t block_size, uint32_t header_off, int hash_size)\n+{\n+\tbw->buf = buf;\n+\tbw->hash_size = hash_size;\n+\tbw->block_size = block_size;\n+\tbw->next = header_off + 4;\n+\tbw->restart_interval = 16;\n+\tbw->entries = 0;\n+\tbw->restart_len = 0;\n+\tbw->last_key.len = 0;\n+}\n+\n+uint8_t block_writer_type(struct block_writer *bw)\n+{\n+}\n+\n+/* adds the reftable_record to the block. Returns -1 if it does not fit, 0 on\n+ success */\n+int block_writer_add(struct block_writer *w, struct reftable_record *rec)\n+{\n+\tstruct strbuf empty = STRBUF_INIT;\n+\tstruct strbuf last =\n+\t\tw->entries % w->restart_interval == 0 ? empty : w->last_key;\n+\tstruct string_view out = {\n+\t\t.buf = w->buf + w->next,\n+\t\t.len = w->block_size - w->next,\n+\t};\n+\n+\tstruct string_view start = out;\n+\n+\tint is_restart = 0;\n+\tstruct strbuf key = STRBUF_INIT;\n+\tint n = 0;\n+\n+\treftable_record_key(rec, &key);\n+\tn = reftable_encode_key(&is_restart, out, last, key,\n+\t\t\t\treftable_record_val_type(rec));\n+\tif (n < 0)\n+\t\tgoto done;\n+\tstring_view_consume(&out, n);\n+\n+\tn = reftable_record_encode(rec, out, w->hash_size);\n+\tif (n < 0)\n+\t\tgoto done;\n+\tstring_view_consume(&out, n);\n+\n+\tif (block_writer_register_restart(w, start.len - out.len, is_restart,\n+\t\t\t\t\t &key) < 0)\n+\t\tgoto done;\n+\n+\tstrbuf_release(&key);\n+\treturn 0;\n+\n+done:\n+\tstrbuf_release(&key);\n+\treturn -1;\n+}\n+\n+int block_writer_register_restart(struct block_writer *w, int n, int is_restart,\n+\t\t\t\t struct strbuf *key)\n+{\n+\tint rlen = w->restart_len;\n+\tif (rlen >= MAX_RESTARTS) {\n+\t\tis_restart = 0;\n+\t}\n+\n+\tif (is_restart) {\n+\t\trlen++;\n+\t}\n+\tif (2 + 3 * rlen + n > w->block_size - w->next)\n+\t\treturn -1;\n+\tif (is_restart) {\n+\t\tif (w->restart_len == w->restart_cap) {\n+\t\t\tw->restart_cap = w->restart_cap * 2 + 1;\n+\t\t\tw->restarts = reftable_realloc(\n+\t\t\t\tw->restarts, sizeof(uint32_t) * w->restart_cap);\n+\t\t}\n+\n+\t\tw->restarts[w->restart_len++] = w->next;\n+\t}\n+\n+\tw->next += n;\n+\n+\tstrbuf_reset(&w->last_key);\n+\tw->entries++;\n+\treturn 0;\n+}\n+\n+int block_writer_finish(struct block_writer *w)\n+{\n+\tint i = 0;\n+\tfor (i = 0; i < w->restart_len; i++) {\n+\t\tput_be24(w->buf + w->next, w->restarts[i]);\n+\t\tw->next += 3;\n+\t}\n+\n+\tput_be16(w->buf + w->next, w->restart_len);\n+\tw->next += 2;\n+\tput_be24(w->buf + 1 + w->header_off, w->next);\n+\n+\tif (block_writer_type(w) == BLOCK_TYPE_LOG) {\n+\t\tuint8_t *compressed = NULL;\n+\t\tint zresult = 0;\n+\t\tuLongf src_len = w->next - block_header_skip;\n+\t\tsize_t dest_cap = src_len;\n+\n+\t\tcompressed = reftable_malloc(dest_cap);\n+\t\twhile (1) {\n+\t\t\tuLongf out_dest_len = dest_cap;\n+\n+\t\t\tzresult = compress2(compressed, &out_dest_len,\n+\t\t\t\t\t 9);\n+\t\t\tif (zresult == Z_BUF_ERROR) {\n+\t\t\t\tdest_cap *= 2;\n+\t\t\t\tcompressed =\n+\t\t\t\t\treftable_realloc(compressed, dest_cap);\n+\t\t\t\tcontinue;\n+\t\t\t}\n+\n+\t\t\tif (Z_OK != zresult) {\n+\t\t\t\treftable_free(compressed);\n+\t\t\t\treturn REFTABLE_ZLIB_ERROR;\n+\t\t\t}\n+\n+\t\t\t out_dest_len);\n+\t\t\tw->next = out_dest_len + block_header_skip;\n+\t\t\treftable_free(compressed);\n+\t\t\tbreak;\n+\t\t}\n+\t}\n+\treturn w->next;\n+}\n+\n+{\n+}\n+\n+\t\t int hash_size)\n+{\n+\tuint32_t full_block_size = table_block_size;\n+\tuint32_t sz = get_be24(block->data + header_off + 1);\n+\n+\tuint16_t restart_count = 0;\n+\tuint32_t restart_start = 0;\n+\tuint8_t *restart_bytes = NULL;\n+\n+\tif (!reftable_is_block_type(typ))\n+\t\treturn REFTABLE_FORMAT_ERROR;\n+\n+\tif (typ == BLOCK_TYPE_LOG) {\n+\t\tuLongf dst_len = sz - block_header_skip; /* total size of dest\n+\t\t\t\t\t\t\t buffer. */\n+\t\tuLongf src_len = block->len - block_header_skip;\n+\t\t/* Log blocks specify the *uncompressed* size in their header.\n+\t\t */\n+\t\tuint8_t *uncompressed = reftable_malloc(sz);\n+\n+\t\t/* Copy over the block header verbatim. It's not compressed. */\n+\n+\t\t/* Uncompress */\n+\t\tif (Z_OK != uncompress_return_consumed(\n+\t\t\t\t &src_len)) {\n+\t\t\treftable_free(uncompressed);\n+\t\t\treturn REFTABLE_ZLIB_ERROR;\n+\t\t}\n+\n+\t\tif (dst_len + block_header_skip != sz)\n+\t\t\treturn REFTABLE_FORMAT_ERROR;\n+\n+\t\t/* We're done with the input data. */\n+\t\treftable_block_done(block);\n+\t\tblock->data = uncompressed;\n+\t\tblock->len = sz;\n+\t\tblock->source = malloc_block_source();\n+\t\tfull_block_size = src_len + block_header_skip;\n+\t} else if (full_block_size == 0) {\n+\t\tfull_block_size = sz;\n+\t} else if (sz < full_block_size && sz < block->len &&\n+\t\t block->data[sz] != 0) {\n+\t\t/* If the block is smaller than the full block size, it is\n+\t\t padded (data followed by '\\0') or the next block is\n+\t\t unaligned. */\n+\t\tfull_block_size = sz;\n+\t}\n+\n+\trestart_count = get_be16(block->data + sz - 2);\n+\trestart_start = sz - 2 - 3 * restart_count;\n+\trestart_bytes = block->data + restart_start;\n+\n+\t/* transfer ownership. */\n+\tbr->block = *block;\n+\tblock->data = NULL;\n+\tblock->len = 0;\n+\n+\tbr->hash_size = hash_size;\n+\tbr->block_len = restart_start;\n+\tbr->full_block_size = full_block_size;\n+\tbr->restart_count = restart_count;\n+\tbr->restart_bytes = restart_bytes;\n+\n+\treturn 0;\n+}\n+\n+{\n+\treturn get_be24(br->restart_bytes + 3 * i);\n+}\n+\n+{\n+\tit->br = br;\n+\tstrbuf_reset(&it->last_key);\n+\tit->next_off = br->header_off + 4;\n+}\n+\n+struct restart_find_args {\n+\tint error;\n+\tstruct strbuf key;\n+};\n+\n+static int restart_key_less(size_t idx, void *args)\n+{\n+\tstruct restart_find_args *a = (struct restart_find_args *)args;\n+\tuint32_t off = block_reader_restart_offset(a->r, idx);\n+\tstruct string_view in = {\n+\t\t.buf = a->r->block.data + off,\n+\t\t.len = a->r->block_len - off,\n+\t};\n+\n+\t/* the restart key is verbatim in the block, so this could avoid the\n+\t alloc for decoding the key */\n+\tstruct strbuf rkey = STRBUF_INIT;\n+\tstruct strbuf last_key = STRBUF_INIT;\n+\tuint8_t unused_extra;\n+\tint n = reftable_decode_key(&rkey, &unused_extra, last_key, in);\n+\tint result;\n+\tif (n < 0) {\n+\t\ta->error = 1;\n+\t\treturn -1;\n+\t}\n+\n+\tresult = strbuf_cmp(&a->key, &rkey);\n+\tstrbuf_release(&rkey);\n+\treturn result;\n+}\n+\n+void block_iter_copy_from(struct block_iter *dest, struct block_iter *src)\n+{\n+\tdest->br = src->br;\n+\tdest->next_off = src->next_off;\n+\tstrbuf_reset(&dest->last_key);\n+}\n+\n+int block_iter_next(struct block_iter *it, struct reftable_record *rec)\n+{\n+\tstruct string_view in = {\n+\t\t.buf = it->br->block.data + it->next_off,\n+\t\t.len = it->br->block_len - it->next_off,\n+\t};\n+\tstruct string_view start = in;\n+\tstruct strbuf key = STRBUF_INIT;\n+\tuint8_t extra = 0;\n+\tint n = 0;\n+\n+\tif (it->next_off >= it->br->block_len)\n+\t\treturn 1;\n+\n+\tn = reftable_decode_key(&key, &extra, it->last_key, in);\n+\tif (n < 0)\n+\t\treturn -1;\n+\n+\tstring_view_consume(&in, n);\n+\tn = reftable_record_decode(rec, key, extra, in, it->br->hash_size);\n+\tif (n < 0)\n+\t\treturn -1;\n+\tstring_view_consume(&in, n);\n+\n+\tstrbuf_reset(&it->last_key);\n+\tit->next_off += start.len - in.len;\n+\tstrbuf_release(&key);\n+\treturn 0;\n+}\n+\n+{\n+\tstruct strbuf empty = STRBUF_INIT;\n+\tint off = br->header_off + 4;\n+\tstruct string_view in = {\n+\t\t.buf = br->block.data + off,\n+\t\t.len = br->block_len - off,\n+\t};\n+\n+\tuint8_t extra = 0;\n+\tint n = reftable_decode_key(key, &extra, empty, in);\n+\tif (n < 0)\n+\t\treturn n;\n+\n+\treturn 0;\n+}\n+\n+int block_iter_seek(struct block_iter *it, struct strbuf *want)\n+{\n+}\n+\n+void block_iter_close(struct block_iter *it)\n+{\n+\tstrbuf_release(&it->last_key);\n+}\n+\n+\t\t struct strbuf *want)\n+{\n+\tstruct restart_find_args args = {\n+\t\t.key = *want,\n+\t\t.r = br,\n+\t};\n+\tstruct reftable_record rec = reftable_new_record(block_reader_type(br));\n+\tstruct strbuf key = STRBUF_INIT;\n+\tint err = 0;\n+\tstruct block_iter next = {\n+\t\t.last_key = STRBUF_INIT,\n+\t};\n+\n+\tint i = binsearch(br->restart_count, &restart_key_less, &args);\n+\tif (args.error) {\n+\t\terr = REFTABLE_FORMAT_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+\tit->br = br;\n+\tif (i > 0) {\n+\t\ti--;\n+\t} else {\n+\t\tit->next_off = br->header_off + 4;\n+\t}\n+\n+\t/* We're looking for the last entry less/equal than the wanted key, so\n+\t we have to go one entry too far and then back up.\n+\t*/\n+\twhile (1) {\n+\t\tblock_iter_copy_from(&next, it);\n+\t\terr = block_iter_next(&next, &rec);\n+\t\tif (err < 0)\n+\t\t\tgoto done;\n+\n+\t\treftable_record_key(&rec, &key);\n+\t\tif (err > 0 || strbuf_cmp(&key, want) >= 0) {\n+\t\t\terr = 0;\n+\t\t\tgoto done;\n+\t\t}\n+\n+\t\tblock_iter_copy_from(it, &next);\n+\t}\n+\n+done:\n+\tstrbuf_release(&key);\n+\tstrbuf_release(&next.last_key);\n+\treftable_record_destroy(&rec);\n+\n+\treturn err;\n+}\n+\n+void block_writer_clear(struct block_writer *bw)\n+{\n+\tFREE_AND_NULL(bw->restarts);\n+\tstrbuf_release(&bw->last_key);\n+\t/* the block is not owned. */\n+}\n+\n+void reftable_block_done(struct reftable_block *blockp)\n+{\n+\tstruct reftable_block_source source = blockp->source;\n+\tif (blockp != NULL && source.ops != NULL)\n+\t\tsource.ops->return_block(source.arg, blockp);\n+\tblockp->data = NULL;\n+\tblockp->len = 0;\n+\tblockp->source.ops = NULL;\n+\tblockp->source.arg = NULL;\n+}\ndiff --git a/reftable/block.h b/reftable/block.h\nnew file mode 100644\nindex 0000000000..14a6f835f4\n--- /dev/null\n+++ b/reftable/block.h\n@@ -0,0 +1,129 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#ifndef BLOCK_H\n+#define BLOCK_H\n+\n+#include \"basics.h\"\n+#include \"record.h\"\n+#include \"reftable.h\"\n+\n+/*\n+ Writes reftable blocks. The block_writer is reused across blocks to minimize\n+*/\n+struct block_writer {\n+\tuint8_t *buf;\n+\tuint32_t block_size;\n+\n+\t/* Offset ofof the global header. Nonzero in the first block only. */\n+\n+\t/* How often to restart keys. */\n+\tint restart_interval;\n+\tint hash_size;\n+\n+\t/* Offset of next uint8_t to write. */\n+\tuint32_t next;\n+\tuint32_t *restarts;\n+\tuint32_t restart_len;\n+\tuint32_t restart_cap;\n+\n+\tstruct strbuf last_key;\n+\tint entries;\n+};\n+\n+/*\n+ initializes the blockwriter to write `typ` entries, using `buf` as temporary\n+ storage. `buf` is not owned by the block_writer. */\n+void block_writer_init(struct block_writer *bw, uint8_t typ, uint8_t *buf,\n+\t\t uint32_t block_size, uint32_t header_off, int hash_size);\n+\n+/*\n+ returns the block type (eg. 'r' for ref records.\n+*/\n+uint8_t block_writer_type(struct block_writer *bw);\n+\n+/* appends the record, or -1 if it doesn't fit. */\n+int block_writer_add(struct block_writer *w, struct reftable_record *rec);\n+\n+/* appends the key restarts, and compress the block if necessary. */\n+int block_writer_finish(struct block_writer *w);\n+\n+/* clears out internally allocated block_writer members. */\n+void block_writer_clear(struct block_writer *bw);\n+\n+\t/* offset of the block header; nonzero for the first block in a\n+\t * reftable. */\n+\n+\t/* the memory block */\n+\tstruct reftable_block block;\n+\tint hash_size;\n+\n+\t/* size of the data, excluding restart data. */\n+\tuint32_t block_len;\n+\tuint8_t *restart_bytes;\n+\tuint16_t restart_count;\n+\n+\t/* size of the data in the file. For log blocks, this is the compressed\n+\t * size. */\n+\tuint32_t full_block_size;\n+};\n+\n+/* Iterate over entries in a block */\n+struct block_iter {\n+\t/* offset within the block of the next entry to read. */\n+\tuint32_t next_off;\n+\n+\t/* key for last entry we read. */\n+\tstruct strbuf last_key;\n+};\n+\n+/* initializes a block reader. */\n+\t\t int hash_size);\n+\n+/* Position `it` at start of the block */\n+\n+/* Position `it` to the `want` key in the block */\n+\t\t struct strbuf *want);\n+\n+/* Returns the block type (eg. 'r' for refs) */\n+\n+/* Decodes the first key in the block */\n+\n+void block_iter_copy_from(struct block_iter *dest, struct block_iter *src);\n+\n+/* return < 0 for error, 0 for OK, > 0 for EOF. */\n+int block_iter_next(struct block_iter *it, struct reftable_record *rec);\n+\n+/* Seek to `want` with in the block pointed to by `it` */\n+int block_iter_seek(struct block_iter *it, struct strbuf *want);\n+\n+/* deallocate memory for `it`. The block reader and its block is left intact. */\n+void block_iter_close(struct block_iter *it);\n+\n+/* size of file header, depending on format version */\n+\n+/* size of file footer, depending on format version */\n+int footer_size(int version);\n+\n+/* returns a block to its source. */\n+void reftable_block_done(struct reftable_block *ret);\n+\n+#endif\ndiff --git a/reftable/block_test.c b/reftable/block_test.c\nnew file mode 100644\nindex 0000000000..1ca327b3c7\n--- /dev/null\n+++ b/reftable/block_test.c\n@@ -0,0 +1,158 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"block.h\"\n+\n+#include \"system.h\"\n+\n+#include \"blocksource.h\"\n+#include \"basics.h\"\n+#include \"constants.h\"\n+#include \"record.h\"\n+#include \"reftable.h\"\n+#include \"test_framework.h\"\n+#include \"reftable-tests.h\"\n+\n+struct binsearch_args {\n+\tint key;\n+\tint *arr;\n+};\n+\n+static int binsearch_func(size_t i, void *void_args)\n+{\n+\tstruct binsearch_args *args = (struct binsearch_args *)void_args;\n+\n+\treturn args->key < args->arr[i];\n+}\n+\n+static void test_binsearch(void)\n+{\n+\tint arr[] = { 2, 4, 6, 8, 10 };\n+\tsize_t sz = ARRAY_SIZE(arr);\n+\tstruct binsearch_args args = {\n+\t\t.arr = arr,\n+\t};\n+\n+\tint i = 0;\n+\tfor (i = 1; i < 11; i++) {\n+\t\tint res;\n+\t\targs.key = i;\n+\t\tres = binsearch(sz, &binsearch_func, &args);\n+\n+\t\tif (res < sz) {\n+\t\t\tassert(args.key < arr[res]);\n+\t\t\tif (res > 0) {\n+\t\t\t\tassert(args.key >= arr[res - 1]);\n+\t\t\t}\n+\t\t} else {\n+\t\t\tassert(args.key == 10 || args.key == 11);\n+\t\t}\n+\t}\n+}\n+\n+{\n+\tconst int header_off = 21; /* random */\n+\tchar *names;\n+\tconst int N = ARRAY_SIZE(names);\n+\tconst int block_size = 1024;\n+\tstruct reftable_block block = { 0 };\n+\tstruct block_writer bw = {\n+\t\t.last_key = STRBUF_INIT,\n+\t};\n+\tstruct reftable_ref_record ref = { 0 };\n+\tstruct reftable_record rec = { 0 };\n+\tint i = 0;\n+\tint n;\n+\tstruct block_reader br = { 0 };\n+\tstruct block_iter it = { .last_key = STRBUF_INIT };\n+\tint j = 0;\n+\tstruct strbuf want = STRBUF_INIT;\n+\n+\tblock.data = reftable_calloc(block_size);\n+\tblock.len = block_size;\n+\tblock.source = malloc_block_source();\n+\tblock_writer_init(&bw, BLOCK_TYPE_REF, block.data, block_size,\n+\treftable_record_from_ref(&rec, &ref);\n+\n+\tfor (i = 0; i < N; i++) {\n+\t\tchar name;\n+\t\tuint8_t hash[SHA1_SIZE];\n+\t\tsnprintf(name, sizeof(name), \"branch%02d\", i);\n+\t\tmemset(hash, i, sizeof(hash));\n+\n+\t\tref.refname = name;\n+\t\tref.value = hash;\n+\t\tnames[i] = xstrdup(name);\n+\t\tref.refname = NULL;\n+\t\tref.value = NULL;\n+\t\tassert(n == 0);\n+\t}\n+\n+\tn = block_writer_finish(&bw);\n+\tassert(n > 0);\n+\n+\tblock_writer_clear(&bw);\n+\n+\n+\n+\twhile (1) {\n+\t\tint r = block_iter_next(&it, &rec);\n+\t\tassert(r >= 0);\n+\t\tif (r > 0) {\n+\t\t\tbreak;\n+\t\t}\n+\t\tassert_streq(names[j], ref.refname);\n+\t\tj++;\n+\t}\n+\n+\treftable_record_clear(&rec);\n+\tblock_iter_close(&it);\n+\n+\tfor (i = 0; i < N; i++) {\n+\t\tstruct block_iter it = { .last_key = STRBUF_INIT };\n+\t\tstrbuf_reset(&want);\n+\n+\t\tn = block_reader_seek(&br, &it, &want);\n+\t\tassert(n == 0);\n+\n+\t\tn = block_iter_next(&it, &rec);\n+\t\tassert(n == 0);\n+\n+\t\tassert_streq(names[i], ref.refname);\n+\n+\t\twant.len--;\n+\t\tn = block_reader_seek(&br, &it, &want);\n+\t\tassert(n == 0);\n+\n+\t\tn = block_iter_next(&it, &rec);\n+\t\tassert(n == 0);\n+\t\tassert_streq(names[10 * (i / 10)], ref.refname);\n+\n+\t\tblock_iter_close(&it);\n+\t}\n+\n+\treftable_record_clear(&rec);\n+\treftable_block_done(&br.block);\n+\tstrbuf_release(&want);\n+\tfor (i = 0; i < N; i++) {\n+\t\treftable_free(names[i]);\n+\t}\n+}\n+\n+int block_test_main(int argc, const char *argv[])\n+{\n+\treturn test_main(argc, argv);\n+}\ndiff --git a/reftable/zlib-compat.c b/reftable/zlib-compat.c\nnew file mode 100644\nindex 0000000000..3e0b0f24f1\n--- /dev/null\n+++ b/reftable/zlib-compat.c\n@@ -0,0 +1,92 @@\n+/* taken from zlib's uncompr.c\n+\n+ commit cacf7f1d4e3d44d871b605da3b647f07d718623f\n+ Date: Sun Jan 15 09:18:46 2017 -0800\n+\n+ zlib 1.2.11\n+\n+*/\n+\n+/*\n+ * Copyright (C) 1995-2003, 2010, 2014, 2016 Jean-loup Gailly, Mark Adler\n+ * For conditions of distribution and use, see copyright notice in zlib.h\n+ */\n+\n+#include \"system.h\"\n+\n+/* clang-format off */\n+\n+/* ===========================================================================\n+ Decompresses the source buffer into the destination buffer. *sourceLen is\n+ the byte length of the source buffer. Upon entry, *destLen is the total size\n+ of the destination buffer, which must be large enough to hold the entire\n+ uncompressed data. (The size of the uncompressed data must have been saved\n+ previously by the compressor and transmitted to the decompressor by some\n+ mechanism outside the scope of this compression library.) Upon exit,\n+ *destLen is the size of the decompressed data and *sourceLen is the number\n+ of source bytes consumed. Upon return, source + *sourceLen points to the\n+ first unused input byte.\n+\n+ uncompress returns Z_OK if success, Z_MEM_ERROR if there was not enough\n+ memory, Z_BUF_ERROR if there was not enough room in the output buffer, or\n+ Z_DATA_ERROR if the input data was corrupted, including if the input data is\n+ an incomplete zlib stream.\n+*/\n+int ZEXPORT uncompress_return_consumed (\n+ Bytef *dest,\n+ uLongf *destLen,\n+ const Bytef *source,\n+ uLong *sourceLen) {\n+ z_stream stream;\n+ int err;\n+ const uInt max = (uInt)-1;\n+ uLong len, left;\n+ Byte buf; /* for detection of incomplete stream when *destLen == 0 */\n+\n+ len = *sourceLen;\n+ if (*destLen) {\n+ left = *destLen;\n+ *destLen = 0;\n+ }\n+ else {\n+ left = 1;\n+ dest = buf;\n+ }\n+\n+ stream.next_in = (z_const Bytef *)source;\n+ stream.avail_in = 0;\n+ stream.zalloc = (alloc_func)0;\n+ stream.zfree = (free_func)0;\n+ stream.opaque = (voidpf)0;\n+\n+ err = inflateInit(&stream);\n+ if (err != Z_OK) return err;\n+\n+ stream.next_out = dest;\n+ stream.avail_out = 0;\n+\n+ do {\n+ if (stream.avail_out == 0) {\n+ stream.avail_out = left > (uLong)max ? max : (uInt)left;\n+ left -= stream.avail_out;\n+ }\n+ if (stream.avail_in == 0) {\n+ stream.avail_in = len > (uLong)max ? max : (uInt)len;\n+ len -= stream.avail_in;\n+ }\n+ err = inflate(&stream, Z_NO_FLUSH);\n+ } while (err == Z_OK);\n+\n+ *sourceLen -= len + stream.avail_in;\n+ if (dest != buf)\n+ *destLen = stream.total_out;\n+ else if (stream.total_out && err == Z_BUF_ERROR)\n+ left = 1;\n+\n+ inflateEnd(&stream);\n+ return err == Z_STREAM_END ? Z_OK :\n+ err == Z_NEED_DICT ? Z_DATA_ERROR :\n+ err == Z_BUF_ERROR && left + stream.avail_out ? Z_DATA_ERROR :\n+ err;\n+}\ndiff --git a/t/helper/test-reftable.c b/t/helper/test-reftable.c\nindex 9341272089..81a9bd5667 100644\n--- a/t/helper/test-reftable.c\n+++ b/t/helper/test-reftable.c\n@@ -3,6 +3,7 @@\n\nint cmd__reftable(int argc, const char **argv)\n{\n+\tblock_test_main(argc, argv);\nrecord_test_main(argc, argv);\nstrbuf_test_main(argc, argv);\nreturn 0;\n--\n\n• ```* [PATCH 08/13] reftable: a generic binary tree implementation\n2020-09-16 19:10 [PATCH 00/13] reftable library Han-Wen Nienhuys via GitGitGadget\n` (6 preceding siblings ...)\n2020-09-16 19:10 ` [PATCH 07/13] reftable: reading/writing blocks Han-Wen Nienhuys via GitGitGadget\n@ 2020-09-16 19:10 ` Han-Wen Nienhuys via GitGitGadget\n2020-09-16 19:10 ` [PATCH 09/13] reftable: write reftable files Han-Wen Nienhuys via GitGitGadget\n` (5 subsequent siblings)\n13 siblings, 0 replies; 251+ messages in thread\nFrom: Han-Wen Nienhuys via GitGitGadget @ 2020-09-16 19:10 UTC (permalink / raw)\nTo: git; +Cc: Han-Wen Nienhuys, Han-Wen Nienhuys\n\nThis is necessary for building a OID => ref map on write\n\n---\nMakefile | 2 ++\nreftable/tree.c | 63 ++++++++++++++++++++++++++++++++++++++++\nreftable/tree.h | 34 ++++++++++++++++++++++\nreftable/tree_test.c | 62 +++++++++++++++++++++++++++++++++++++++\nt/helper/test-reftable.c | 1 +\n5 files changed, 162 insertions(+)\ncreate mode 100644 reftable/tree.c\ncreate mode 100644 reftable/tree.h\ncreate mode 100644 reftable/tree_test.c\n\ndiff --git a/Makefile b/Makefile\nindex a897818a7e..b96c235087 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -2351,12 +2351,14 @@ REFTABLE_OBJS += reftable/publicbasics.o\nREFTABLE_OBJS += reftable/compat.o\nREFTABLE_OBJS += reftable/record.o\nREFTABLE_OBJS += reftable/strbuf.o\n+REFTABLE_OBJS += reftable/tree.o\nREFTABLE_OBJS += reftable/zlib-compat.o\n\nREFTABLE_TEST_OBJS += reftable/block_test.o\nREFTABLE_TEST_OBJS += reftable/record_test.o\nREFTABLE_TEST_OBJS += reftable/strbuf_test.o\nREFTABLE_TEST_OBJS += reftable/test_framework.o\n+REFTABLE_TEST_OBJS += reftable/tree_test.o\n\nTEST_OBJS := \\$(patsubst %\\$X,%.o,\\$(TEST_PROGRAMS)) \\$(patsubst %,t/helper/%,\\$(TEST_BUILTINS_OBJS))\nOBJECTS := \\$(LIB_OBJS) \\$(BUILTIN_OBJS) \\$(PROGRAM_OBJS) \\$(TEST_OBJS) \\\ndiff --git a/reftable/tree.c b/reftable/tree.c\nnew file mode 100644\nindex 0000000000..0061d14e30\n--- /dev/null\n+++ b/reftable/tree.c\n@@ -0,0 +1,63 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"tree.h\"\n+\n+#include \"basics.h\"\n+#include \"system.h\"\n+\n+struct tree_node *tree_search(void *key, struct tree_node **rootp,\n+\t\t\t int (*compare)(const void *, const void *),\n+\t\t\t int insert)\n+{\n+\tint res;\n+\tif (*rootp == NULL) {\n+\t\tif (!insert) {\n+\t\t\treturn NULL;\n+\t\t} else {\n+\t\t\tstruct tree_node *n =\n+\t\t\t\treftable_calloc(sizeof(struct tree_node));\n+\t\t\tn->key = key;\n+\t\t\t*rootp = n;\n+\t\t\treturn *rootp;\n+\t\t}\n+\t}\n+\n+\tres = compare(key, (*rootp)->key);\n+\tif (res < 0)\n+\t\treturn tree_search(key, &(*rootp)->left, compare, insert);\n+\telse if (res > 0)\n+\t\treturn tree_search(key, &(*rootp)->right, compare, insert);\n+\treturn *rootp;\n+}\n+\n+void infix_walk(struct tree_node *t, void (*action)(void *arg, void *key),\n+\t\tvoid *arg)\n+{\n+\tif (t->left != NULL) {\n+\t\tinfix_walk(t->left, action, arg);\n+\t}\n+\taction(arg, t->key);\n+\tif (t->right != NULL) {\n+\t\tinfix_walk(t->right, action, arg);\n+\t}\n+}\n+\n+void tree_free(struct tree_node *t)\n+{\n+\tif (t == NULL) {\n+\t\treturn;\n+\t}\n+\tif (t->left != NULL) {\n+\t\ttree_free(t->left);\n+\t}\n+\tif (t->right != NULL) {\n+\t\ttree_free(t->right);\n+\t}\n+\treftable_free(t);\n+}\ndiff --git a/reftable/tree.h b/reftable/tree.h\nnew file mode 100644\nindex 0000000000..954512e9a3\n--- /dev/null\n+++ b/reftable/tree.h\n@@ -0,0 +1,34 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#ifndef TREE_H\n+#define TREE_H\n+\n+/* tree_node is a generic binary search tree. */\n+struct tree_node {\n+\tvoid *key;\n+\tstruct tree_node *left, *right;\n+};\n+\n+/* looks for `key` in `rootp` using `compare` as comparison function. If insert\n+ is set, insert the key if it's not found. Else, return NULL.\n+*/\n+struct tree_node *tree_search(void *key, struct tree_node **rootp,\n+\t\t\t int (*compare)(const void *, const void *),\n+\t\t\t int insert);\n+\n+/* performs an infix walk of the tree. */\n+void infix_walk(struct tree_node *t, void (*action)(void *arg, void *key),\n+\t\tvoid *arg);\n+\n+/*\n+ deallocates the tree nodes recursively. Keys should be deallocated separately\n+ by walking over the tree. */\n+void tree_free(struct tree_node *t);\n+\n+#endif\ndiff --git a/reftable/tree_test.c b/reftable/tree_test.c\nnew file mode 100644\nindex 0000000000..c6d448cbe8\n--- /dev/null\n+++ b/reftable/tree_test.c\n@@ -0,0 +1,62 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"tree.h\"\n+\n+#include \"basics.h\"\n+#include \"record.h\"\n+#include \"reftable.h\"\n+#include \"test_framework.h\"\n+#include \"reftable-tests.h\"\n+\n+static int test_compare(const void *a, const void *b)\n+{\n+\treturn (char *)a - (char *)b;\n+}\n+\n+struct curry {\n+\tvoid *last;\n+};\n+\n+static void check_increasing(void *arg, void *key)\n+{\n+\tstruct curry *c = (struct curry *)arg;\n+\tif (c->last != NULL) {\n+\t\tassert(test_compare(c->last, key) < 0);\n+\t}\n+\tc->last = key;\n+}\n+\n+static void test_tree(void)\n+{\n+\tstruct tree_node *root = NULL;\n+\n+\tvoid *values = { 0 };\n+\tstruct tree_node *nodes = { 0 };\n+\tint i = 1;\n+\tstruct curry c = { 0 };\n+\tdo {\n+\t\tnodes[i] = tree_search(values + i, &root, &test_compare, 1);\n+\t\ti = (i * 7) % 11;\n+\t} while (i != 1);\n+\n+\tfor (i = 1; i < ARRAY_SIZE(nodes); i++) {\n+\t\tassert(values + i == nodes[i]->key);\n+\t\tassert(nodes[i] ==\n+\t\t tree_search(values + i, &root, &test_compare, 0));\n+\t}\n+\n+\tinfix_walk(root, check_increasing, &c);\n+\ttree_free(root);\n+}\n+\n+int tree_test_main(int argc, const char *argv[])\n+{\n+\treturn test_main(argc, argv);\n+}\ndiff --git a/t/helper/test-reftable.c b/t/helper/test-reftable.c\nindex 81a9bd5667..9c4e0f42dc 100644\n--- a/t/helper/test-reftable.c\n+++ b/t/helper/test-reftable.c\n@@ -6,5 +6,6 @@ int cmd__reftable(int argc, const char **argv)\nblock_test_main(argc, argv);\nrecord_test_main(argc, argv);\nstrbuf_test_main(argc, argv);\n+\ttree_test_main(argc, argv);\nreturn 0;\n}\n--\n\n• ```* [PATCH 09/13] reftable: write reftable files\n2020-09-16 19:10 [PATCH 00/13] reftable library Han-Wen Nienhuys via GitGitGadget\n` (7 preceding siblings ...)\n2020-09-16 19:10 ` [PATCH 08/13] reftable: a generic binary tree implementation Han-Wen Nienhuys via GitGitGadget\n@ 2020-09-16 19:10 ` Han-Wen Nienhuys via GitGitGadget\n2020-09-16 19:10 ` [PATCH 10/13] reftable: read \" Han-Wen Nienhuys via GitGitGadget\n` (4 subsequent siblings)\n13 siblings, 0 replies; 251+ messages in thread\nFrom: Han-Wen Nienhuys via GitGitGadget @ 2020-09-16 19:10 UTC (permalink / raw)\nTo: git; +Cc: Han-Wen Nienhuys, Han-Wen Nienhuys\n\n---\nMakefile | 1 +\nreftable/writer.c | 664 ++++++++++++++++++++++++++++++++++++++++++++++\nreftable/writer.h | 60 +++++\n3 files changed, 725 insertions(+)\ncreate mode 100644 reftable/writer.c\ncreate mode 100644 reftable/writer.h\n\ndiff --git a/Makefile b/Makefile\nindex b96c235087..a200633945 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -2352,6 +2352,7 @@ REFTABLE_OBJS += reftable/compat.o\nREFTABLE_OBJS += reftable/record.o\nREFTABLE_OBJS += reftable/strbuf.o\nREFTABLE_OBJS += reftable/tree.o\n+REFTABLE_OBJS += reftable/writer.o\nREFTABLE_OBJS += reftable/zlib-compat.o\n\nREFTABLE_TEST_OBJS += reftable/block_test.o\ndiff --git a/reftable/writer.c b/reftable/writer.c\nnew file mode 100644\nindex 0000000000..44ddcc6757\n--- /dev/null\n+++ b/reftable/writer.c\n@@ -0,0 +1,664 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"writer.h\"\n+\n+#include \"system.h\"\n+\n+#include \"block.h\"\n+#include \"constants.h\"\n+#include \"record.h\"\n+#include \"reftable.h\"\n+#include \"tree.h\"\n+\n+static struct reftable_block_stats *\n+writer_reftable_block_stats(struct reftable_writer *w, uint8_t typ)\n+{\n+\tswitch (typ) {\n+\tcase 'r':\n+\t\treturn &w->stats.ref_stats;\n+\tcase 'o':\n+\t\treturn &w->stats.obj_stats;\n+\tcase 'i':\n+\t\treturn &w->stats.idx_stats;\n+\tcase 'g':\n+\t\treturn &w->stats.log_stats;\n+\t}\n+\tabort();\n+\treturn NULL;\n+}\n+\n+/* write data, queuing the padding for the next write. Returns negative for\n+ * error. */\n+static int padded_write(struct reftable_writer *w, uint8_t *data, size_t len,\n+{\n+\tint n = 0;\n+\tif (w->pending_padding > 0) {\n+\t\tint n = w->write(w->write_arg, zeroed, w->pending_padding);\n+\t\tif (n < 0)\n+\t\t\treturn n;\n+\n+\t\treftable_free(zeroed);\n+\t}\n+\n+\tn = w->write(w->write_arg, data, len);\n+\tif (n < 0)\n+\t\treturn n;\n+\treturn 0;\n+}\n+\n+static void options_set_defaults(struct reftable_write_options *opts)\n+{\n+\tif (opts->restart_interval == 0) {\n+\t\topts->restart_interval = 16;\n+\t}\n+\n+\tif (opts->hash_id == 0) {\n+\t\topts->hash_id = SHA1_ID;\n+\t}\n+\tif (opts->block_size == 0) {\n+\t\topts->block_size = DEFAULT_BLOCK_SIZE;\n+\t}\n+}\n+\n+static int writer_version(struct reftable_writer *w)\n+{\n+\treturn (w->opts.hash_id == 0 || w->opts.hash_id == SHA1_ID) ? 1 : 2;\n+}\n+\n+static int writer_write_header(struct reftable_writer *w, uint8_t *dest)\n+{\n+\tmemcpy((char *)dest, \"REFT\", 4);\n+\n+\tdest = writer_version(w);\n+\n+\tput_be24(dest + 5, w->opts.block_size);\n+\tput_be64(dest + 8, w->min_update_index);\n+\tput_be64(dest + 16, w->max_update_index);\n+\tif (writer_version(w) == 2) {\n+\t\tput_be32(dest + 24, w->opts.hash_id);\n+\t}\n+}\n+\n+static void writer_reinit_block_writer(struct reftable_writer *w, uint8_t typ)\n+{\n+\tint block_start = 0;\n+\tif (w->next == 0) {\n+\t}\n+\n+\tstrbuf_release(&w->last_key);\n+\tblock_writer_init(&w->block_writer_data, typ, w->block,\n+\t\t\t w->opts.block_size, block_start,\n+\t\t\t hash_size(w->opts.hash_id));\n+\tw->block_writer = &w->block_writer_data;\n+\tw->block_writer->restart_interval = w->opts.restart_interval;\n+}\n+\n+struct reftable_writer *\n+reftable_new_writer(int (*writer_func)(void *, const void *, size_t),\n+\t\t void *writer_arg, struct reftable_write_options *opts)\n+{\n+\tstruct reftable_writer *wp =\n+\t\treftable_calloc(sizeof(struct reftable_writer));\n+\tstrbuf_init(&wp->block_writer_data.last_key, 0);\n+\toptions_set_defaults(opts);\n+\tif (opts->block_size >= (1 << 24)) {\n+\t\t/* TODO - error return? */\n+\t\tabort();\n+\t}\n+\twp->last_key = reftable_empty_strbuf;\n+\twp->block = reftable_calloc(opts->block_size);\n+\twp->write = writer_func;\n+\twp->write_arg = writer_arg;\n+\twp->opts = *opts;\n+\twriter_reinit_block_writer(wp, BLOCK_TYPE_REF);\n+\n+\treturn wp;\n+}\n+\n+void reftable_writer_set_limits(struct reftable_writer *w, uint64_t min,\n+\t\t\t\tuint64_t max)\n+{\n+\tw->min_update_index = min;\n+\tw->max_update_index = max;\n+}\n+\n+void reftable_writer_free(struct reftable_writer *w)\n+{\n+\treftable_free(w->block);\n+\treftable_free(w);\n+}\n+\n+struct obj_index_tree_node {\n+\tstruct strbuf hash;\n+\tuint64_t *offsets;\n+\tsize_t offset_len;\n+\tsize_t offset_cap;\n+};\n+\n+#define OBJ_INDEX_TREE_NODE_INIT \\\n+\t{ \\\n+\t\t.hash = STRBUF_INIT \\\n+\t}\n+\n+static int obj_index_tree_node_compare(const void *a, const void *b)\n+{\n+\treturn strbuf_cmp(&((const struct obj_index_tree_node *)a)->hash,\n+\t\t\t &((const struct obj_index_tree_node *)b)->hash);\n+}\n+\n+static void writer_index_hash(struct reftable_writer *w, struct strbuf *hash)\n+{\n+\tuint64_t off = w->next;\n+\n+\tstruct obj_index_tree_node want = { .hash = *hash };\n+\n+\tstruct tree_node *node = tree_search(&want, &w->obj_index_tree,\n+\t\t\t\t\t &obj_index_tree_node_compare, 0);\n+\tstruct obj_index_tree_node *key = NULL;\n+\tif (node == NULL) {\n+\t\tstruct obj_index_tree_node empty = OBJ_INDEX_TREE_NODE_INIT;\n+\t\tkey = reftable_malloc(sizeof(struct obj_index_tree_node));\n+\t\t*key = empty;\n+\n+\t\tstrbuf_reset(&key->hash);\n+\t\ttree_search((void *)key, &w->obj_index_tree,\n+\t\t\t &obj_index_tree_node_compare, 1);\n+\t} else {\n+\t\tkey = node->key;\n+\t}\n+\n+\tif (key->offset_len > 0 && key->offsets[key->offset_len - 1] == off) {\n+\t\treturn;\n+\t}\n+\n+\tif (key->offset_len == key->offset_cap) {\n+\t\tkey->offset_cap = 2 * key->offset_cap + 1;\n+\t\tkey->offsets = reftable_realloc(\n+\t\t\tkey->offsets, sizeof(uint64_t) * key->offset_cap);\n+\t}\n+\n+\tkey->offsets[key->offset_len++] = off;\n+}\n+\n+\t\t\t struct reftable_record *rec)\n+{\n+\tint result = -1;\n+\tstruct strbuf key = STRBUF_INIT;\n+\tint err = 0;\n+\treftable_record_key(rec, &key);\n+\tif (strbuf_cmp(&w->last_key, &key) >= 0)\n+\t\tgoto done;\n+\n+\tstrbuf_reset(&w->last_key);\n+\tif (w->block_writer == NULL) {\n+\t\twriter_reinit_block_writer(w, reftable_record_type(rec));\n+\t}\n+\n+\tassert(block_writer_type(w->block_writer) == reftable_record_type(rec));\n+\n+\tif (block_writer_add(w->block_writer, rec) == 0) {\n+\t\tresult = 0;\n+\t\tgoto done;\n+\t}\n+\n+\terr = writer_flush_block(w);\n+\tif (err < 0) {\n+\t\tresult = err;\n+\t\tgoto done;\n+\t}\n+\n+\twriter_reinit_block_writer(w, reftable_record_type(rec));\n+\tif (err < 0) {\n+\t\tresult = err;\n+\t\tgoto done;\n+\t}\n+\n+\tresult = 0;\n+done:\n+\tstrbuf_release(&key);\n+\treturn result;\n+}\n+\n+\t\t\t struct reftable_ref_record *ref)\n+{\n+\tstruct reftable_record rec = { 0 };\n+\tstruct reftable_ref_record copy = *ref;\n+\tint err = 0;\n+\n+\tif (ref->refname == NULL)\n+\t\treturn REFTABLE_API_ERROR;\n+\tif (ref->update_index < w->min_update_index ||\n+\t ref->update_index > w->max_update_index)\n+\t\treturn REFTABLE_API_ERROR;\n+\n+\treftable_record_from_ref(&rec, &copy);\n+\tcopy.update_index -= w->min_update_index;\n+\tif (err < 0)\n+\t\treturn err;\n+\n+\tif (!w->opts.skip_index_objects && ref->value != NULL) {\n+\t\tstruct strbuf h = STRBUF_INIT;\n+\t\twriter_index_hash(w, &h);\n+\t\tstrbuf_release(&h);\n+\t}\n+\n+\tif (!w->opts.skip_index_objects && ref->target_value != NULL) {\n+\t\tstruct strbuf h = STRBUF_INIT;\n+\t\twriter_index_hash(w, &h);\n+\t\tstrbuf_release(&h);\n+\t}\n+\treturn 0;\n+}\n+\n+\t\t\t struct reftable_ref_record *refs, int n)\n+{\n+\tint err = 0;\n+\tint i = 0;\n+\tQSORT(refs, n, reftable_ref_record_compare_name);\n+\tfor (i = 0; err == 0 && i < n; i++) {\n+\t}\n+\treturn err;\n+}\n+\n+\t\t\t struct reftable_log_record *log)\n+{\n+\tstruct reftable_record rec = { 0 };\n+\tchar *input_log_message = log->message;\n+\tstruct strbuf cleaned_message = STRBUF_INIT;\n+\tint err;\n+\tif (log->refname == NULL)\n+\t\treturn REFTABLE_API_ERROR;\n+\n+\tif (w->block_writer != NULL &&\n+\t block_writer_type(w->block_writer) == BLOCK_TYPE_REF) {\n+\t\tint err = writer_finish_public_section(w);\n+\t\tif (err < 0)\n+\t\t\treturn err;\n+\t}\n+\n+\tif (!w->opts.exact_log_message && log->message != NULL) {\n+\t\twhile (cleaned_message.len &&\n+\t\t cleaned_message.buf[cleaned_message.len - 1] == '\\n')\n+\t\t\tstrbuf_setlen(&cleaned_message,\n+\t\t\t\t cleaned_message.len - 1);\n+\t\tif (strchr(cleaned_message.buf, '\\n')) {\n+\t\t\t// multiple lines not allowed.\n+\t\t\terr = REFTABLE_API_ERROR;\n+\t\t\tgoto done;\n+\t\t}\n+\t\tlog->message = cleaned_message.buf;\n+\t}\n+\n+\n+\treftable_record_from_log(&rec, log);\n+\n+done:\n+\tlog->message = input_log_message;\n+\tstrbuf_release(&cleaned_message);\n+\treturn err;\n+}\n+\n+\t\t\t struct reftable_log_record *logs, int n)\n+{\n+\tint err = 0;\n+\tint i = 0;\n+\tQSORT(logs, n, reftable_log_record_compare_key);\n+\tfor (i = 0; err == 0 && i < n; i++) {\n+\t}\n+\treturn err;\n+}\n+\n+static int writer_finish_section(struct reftable_writer *w)\n+{\n+\tuint8_t typ = block_writer_type(w->block_writer);\n+\tuint64_t index_start = 0;\n+\tint max_level = 0;\n+\tint threshold = w->opts.unpadded ? 1 : 3;\n+\tint before_blocks = w->stats.idx_stats.blocks;\n+\tint err = writer_flush_block(w);\n+\tint i = 0;\n+\tstruct reftable_block_stats *bstats = NULL;\n+\tif (err < 0)\n+\t\treturn err;\n+\n+\twhile (w->index_len > threshold) {\n+\t\tstruct reftable_index_record *idx = NULL;\n+\t\tint idx_len = 0;\n+\n+\t\tmax_level++;\n+\t\tindex_start = w->next;\n+\t\twriter_reinit_block_writer(w, BLOCK_TYPE_INDEX);\n+\n+\t\tidx = w->index;\n+\t\tidx_len = w->index_len;\n+\n+\t\tw->index = NULL;\n+\t\tw->index_len = 0;\n+\t\tw->index_cap = 0;\n+\t\tfor (i = 0; i < idx_len; i++) {\n+\t\t\tstruct reftable_record rec = { 0 };\n+\t\t\treftable_record_from_index(&rec, idx + i);\n+\t\t\tif (block_writer_add(w->block_writer, &rec) == 0) {\n+\t\t\t\tcontinue;\n+\t\t\t}\n+\n+\t\t\terr = writer_flush_block(w);\n+\t\t\tif (err < 0)\n+\t\t\t\treturn err;\n+\n+\t\t\twriter_reinit_block_writer(w, BLOCK_TYPE_INDEX);\n+\n+\t\t\tif (err != 0) {\n+\t\t\t\t/* write into fresh block should always succeed\n+\t\t\t\t */\n+\t\t\t\tabort();\n+\t\t\t}\n+\t\t}\n+\t\tfor (i = 0; i < idx_len; i++) {\n+\t\t\tstrbuf_release(&idx[i].last_key);\n+\t\t}\n+\t\treftable_free(idx);\n+\t}\n+\n+\twriter_clear_index(w);\n+\n+\terr = writer_flush_block(w);\n+\tif (err < 0)\n+\t\treturn err;\n+\n+\tbstats = writer_reftable_block_stats(w, typ);\n+\tbstats->index_blocks = w->stats.idx_stats.blocks - before_blocks;\n+\tbstats->index_offset = index_start;\n+\tbstats->max_index_level = max_level;\n+\n+\t/* Reinit lastKey, as the next section can start with any key. */\n+\tw->last_key.len = 0;\n+\n+\treturn 0;\n+}\n+\n+struct common_prefix_arg {\n+\tstruct strbuf *last;\n+\tint max;\n+};\n+\n+static void update_common(void *void_arg, void *key)\n+{\n+\tstruct common_prefix_arg *arg = (struct common_prefix_arg *)void_arg;\n+\tstruct obj_index_tree_node *entry = (struct obj_index_tree_node *)key;\n+\tif (arg->last != NULL) {\n+\t\tint n = common_prefix_size(&entry->hash, arg->last);\n+\t\tif (n > arg->max) {\n+\t\t\targ->max = n;\n+\t\t}\n+\t}\n+\targ->last = &entry->hash;\n+}\n+\n+struct write_record_arg {\n+\tstruct reftable_writer *w;\n+\tint err;\n+};\n+\n+static void write_object_record(void *void_arg, void *key)\n+{\n+\tstruct write_record_arg *arg = (struct write_record_arg *)void_arg;\n+\tstruct obj_index_tree_node *entry = (struct obj_index_tree_node *)key;\n+\tstruct reftable_obj_record obj_rec = {\n+\t\t.hash_prefix = (uint8_t *)entry->hash.buf,\n+\t\t.hash_prefix_len = arg->w->stats.object_id_len,\n+\t\t.offsets = entry->offsets,\n+\t\t.offset_len = entry->offset_len,\n+\t};\n+\tstruct reftable_record rec = { 0 };\n+\tif (arg->err < 0)\n+\t\tgoto done;\n+\n+\treftable_record_from_obj(&rec, &obj_rec);\n+\tif (arg->err == 0)\n+\t\tgoto done;\n+\n+\targ->err = writer_flush_block(arg->w);\n+\tif (arg->err < 0)\n+\t\tgoto done;\n+\n+\twriter_reinit_block_writer(arg->w, BLOCK_TYPE_OBJ);\n+\tif (arg->err == 0)\n+\t\tgoto done;\n+\tobj_rec.offset_len = 0;\n+\n+\t/* Should be able to write into a fresh block. */\n+\tassert(arg->err == 0);\n+\n+done:;\n+}\n+\n+static void object_record_free(void *void_arg, void *key)\n+{\n+\tstruct obj_index_tree_node *entry = (struct obj_index_tree_node *)key;\n+\n+\tFREE_AND_NULL(entry->offsets);\n+\tstrbuf_release(&entry->hash);\n+\treftable_free(entry);\n+}\n+\n+static int writer_dump_object_index(struct reftable_writer *w)\n+{\n+\tstruct write_record_arg closure = { .w = w };\n+\tstruct common_prefix_arg common = { 0 };\n+\tif (w->obj_index_tree != NULL) {\n+\t\tinfix_walk(w->obj_index_tree, &update_common, &common);\n+\t}\n+\tw->stats.object_id_len = common.max + 1;\n+\n+\twriter_reinit_block_writer(w, BLOCK_TYPE_OBJ);\n+\n+\tif (w->obj_index_tree != NULL) {\n+\t\tinfix_walk(w->obj_index_tree, &write_object_record, &closure);\n+\t}\n+\n+\tif (closure.err < 0)\n+\t\treturn closure.err;\n+\treturn writer_finish_section(w);\n+}\n+\n+int writer_finish_public_section(struct reftable_writer *w)\n+{\n+\tuint8_t typ = 0;\n+\tint err = 0;\n+\n+\tif (w->block_writer == NULL)\n+\t\treturn 0;\n+\n+\ttyp = block_writer_type(w->block_writer);\n+\terr = writer_finish_section(w);\n+\tif (err < 0)\n+\t\treturn err;\n+\tif (typ == BLOCK_TYPE_REF && !w->opts.skip_index_objects &&\n+\t w->stats.ref_stats.index_blocks > 0) {\n+\t\terr = writer_dump_object_index(w);\n+\t\tif (err < 0)\n+\t\t\treturn err;\n+\t}\n+\n+\tif (w->obj_index_tree != NULL) {\n+\t\tinfix_walk(w->obj_index_tree, &object_record_free, NULL);\n+\t\ttree_free(w->obj_index_tree);\n+\t\tw->obj_index_tree = NULL;\n+\t}\n+\n+\tw->block_writer = NULL;\n+\treturn 0;\n+}\n+\n+int reftable_writer_close(struct reftable_writer *w)\n+{\n+\tuint8_t footer;\n+\tuint8_t *p = footer;\n+\tint err = writer_finish_public_section(w);\n+\tint empty_table = w->next == 0;\n+\tif (err != 0)\n+\t\tgoto done;\n+\tif (empty_table) {\n+\t\t/* Empty tables need a header anyway. */\n+\t\tif (err < 0)\n+\t\t\tgoto done;\n+\t}\n+\n+\tput_be64(p, w->stats.ref_stats.index_offset);\n+\tp += 8;\n+\tput_be64(p, (w->stats.obj_stats.offset) << 5 | w->stats.object_id_len);\n+\tp += 8;\n+\tput_be64(p, w->stats.obj_stats.index_offset);\n+\tp += 8;\n+\n+\tput_be64(p, w->stats.log_stats.offset);\n+\tp += 8;\n+\tput_be64(p, w->stats.log_stats.index_offset);\n+\tp += 8;\n+\n+\tput_be32(p, crc32(0, footer, p - footer));\n+\tp += 4;\n+\n+\terr = padded_write(w, footer, footer_size(writer_version(w)), 0);\n+\tif (err < 0)\n+\t\tgoto done;\n+\n+\tif (empty_table) {\n+\t\terr = REFTABLE_EMPTY_TABLE_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+done:\n+\t/* free up memory. */\n+\tblock_writer_clear(&w->block_writer_data);\n+\twriter_clear_index(w);\n+\tstrbuf_release(&w->last_key);\n+\treturn err;\n+}\n+\n+void writer_clear_index(struct reftable_writer *w)\n+{\n+\tint i = 0;\n+\tfor (i = 0; i < w->index_len; i++) {\n+\t\tstrbuf_release(&w->index[i].last_key);\n+\t}\n+\n+\tFREE_AND_NULL(w->index);\n+\tw->index_len = 0;\n+\tw->index_cap = 0;\n+}\n+\n+const int debug = 0;\n+\n+static int writer_flush_nonempty_block(struct reftable_writer *w)\n+{\n+\tuint8_t typ = block_writer_type(w->block_writer);\n+\tstruct reftable_block_stats *bstats =\n+\t\twriter_reftable_block_stats(w, typ);\n+\tuint64_t block_typ_off = (bstats->blocks == 0) ? w->next : 0;\n+\tint raw_bytes = block_writer_finish(w->block_writer);\n+\tint err = 0;\n+\tstruct reftable_index_record ir = { .last_key = STRBUF_INIT };\n+\tif (raw_bytes < 0)\n+\t\treturn raw_bytes;\n+\n+\tif (!w->opts.unpadded && typ != BLOCK_TYPE_LOG) {\n+\t\tpadding = w->opts.block_size - raw_bytes;\n+\t}\n+\n+\tif (block_typ_off > 0) {\n+\t\tbstats->offset = block_typ_off;\n+\t}\n+\n+\tbstats->entries += w->block_writer->entries;\n+\tbstats->restarts += w->block_writer->restart_len;\n+\tbstats->blocks++;\n+\tw->stats.blocks++;\n+\n+\tif (debug) {\n+\t\tfprintf(stderr, \"block %c off %\" PRIu64 \" sz %d (%d)\\n\", typ,\n+\t\t\tw->next, raw_bytes,\n+\t\t\tget_be24(w->block + w->block_writer->header_off + 1));\n+\t}\n+\n+\tif (w->next == 0) {\n+\t}\n+\n+\tif (err < 0)\n+\t\treturn err;\n+\n+\tif (w->index_cap == w->index_len) {\n+\t\tw->index_cap = 2 * w->index_cap + 1;\n+\t\tw->index = reftable_realloc(\n+\t\t\tw->index,\n+\t\t\tsizeof(struct reftable_index_record) * w->index_cap);\n+\t}\n+\n+\tir.offset = w->next;\n+\tstrbuf_reset(&ir.last_key);\n+\tw->index[w->index_len] = ir;\n+\n+\tw->index_len++;\n+\tw->next += padding + raw_bytes;\n+\tw->block_writer = NULL;\n+\treturn 0;\n+}\n+\n+int writer_flush_block(struct reftable_writer *w)\n+{\n+\tif (w->block_writer == NULL)\n+\t\treturn 0;\n+\tif (w->block_writer->entries == 0)\n+\t\treturn 0;\n+\treturn writer_flush_nonempty_block(w);\n+}\n+\n+const struct reftable_stats *writer_stats(struct reftable_writer *w)\n+{\n+\treturn &w->stats;\n+}\ndiff --git a/reftable/writer.h b/reftable/writer.h\nnew file mode 100644\nindex 0000000000..c69ecffea0\n--- /dev/null\n+++ b/reftable/writer.h\n@@ -0,0 +1,60 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#ifndef WRITER_H\n+#define WRITER_H\n+\n+#include \"basics.h\"\n+#include \"block.h\"\n+#include \"reftable.h\"\n+#include \"strbuf.h\"\n+#include \"tree.h\"\n+\n+struct reftable_writer {\n+\tint (*write)(void *, const void *, size_t);\n+\tvoid *write_arg;\n+\tstruct strbuf last_key;\n+\n+\t/* offset of next block to write. */\n+\tuint64_t next;\n+\tuint64_t min_update_index, max_update_index;\n+\tstruct reftable_write_options opts;\n+\n+\t/* memory buffer for writing */\n+\tuint8_t *block;\n+\n+\t/* writer for the current section. NULL or points to\n+\t * block_writer_data */\n+\tstruct block_writer *block_writer;\n+\n+\tstruct block_writer block_writer_data;\n+\n+\t/* pending index records for the current section */\n+\tstruct reftable_index_record *index;\n+\tsize_t index_len;\n+\tsize_t index_cap;\n+\n+\t/*\n+\t tree for use with tsearch; used to populate the 'o' inverse OID\n+\t map */\n+\tstruct tree_node *obj_index_tree;\n+\n+\tstruct reftable_stats stats;\n+};\n+\n+/* finishes a block, and writes it to storage */\n+int writer_flush_block(struct reftable_writer *w);\n+\n+/* deallocates memory related to the index */\n+void writer_clear_index(struct reftable_writer *w);\n+\n+/* finishes writing a 'r' (refs) or 'g' (reflogs) section */\n+int writer_finish_public_section(struct reftable_writer *w);\n+\n+#endif\n--\n\n• ```* [PATCH 10/13] reftable: read reftable files\n2020-09-16 19:10 [PATCH 00/13] reftable library Han-Wen Nienhuys via GitGitGadget\n` (8 preceding siblings ...)\n2020-09-16 19:10 ` [PATCH 09/13] reftable: write reftable files Han-Wen Nienhuys via GitGitGadget\n@ 2020-09-16 19:10 ` Han-Wen Nienhuys via GitGitGadget\n2020-09-16 19:10 ` [PATCH 11/13] reftable: file level tests Han-Wen Nienhuys via GitGitGadget\n` (3 subsequent siblings)\n13 siblings, 0 replies; 251+ messages in thread\nFrom: Han-Wen Nienhuys via GitGitGadget @ 2020-09-16 19:10 UTC (permalink / raw)\nTo: git; +Cc: Han-Wen Nienhuys, Han-Wen Nienhuys\n\n---\nMakefile | 3 +\nreftable/iter.c | 242 +++++++++++++++\nreftable/iter.h | 72 +++++\nreftable/reftable.c | 104 +++++++\n6 files changed, 1232 insertions(+)\ncreate mode 100644 reftable/iter.c\ncreate mode 100644 reftable/iter.h\ncreate mode 100644 reftable/reftable.c\n\ndiff --git a/Makefile b/Makefile\nindex a200633945..275fc4227c 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -2349,7 +2349,10 @@ REFTABLE_OBJS += reftable/block.o\nREFTABLE_OBJS += reftable/blocksource.o\nREFTABLE_OBJS += reftable/publicbasics.o\nREFTABLE_OBJS += reftable/compat.o\n+REFTABLE_OBJS += reftable/iter.o\nREFTABLE_OBJS += reftable/record.o\n+REFTABLE_OBJS += reftable/reftable.o\nREFTABLE_OBJS += reftable/strbuf.o\nREFTABLE_OBJS += reftable/tree.o\nREFTABLE_OBJS += reftable/writer.o\ndiff --git a/reftable/iter.c b/reftable/iter.c\nnew file mode 100644\nindex 0000000000..6631408ef8\n--- /dev/null\n+++ b/reftable/iter.c\n@@ -0,0 +1,242 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"iter.h\"\n+\n+#include \"system.h\"\n+\n+#include \"block.h\"\n+#include \"constants.h\"\n+#include \"reftable.h\"\n+\n+int iterator_is_null(struct reftable_iterator *it)\n+{\n+\treturn it->ops == NULL;\n+}\n+\n+static int empty_iterator_next(void *arg, struct reftable_record *rec)\n+{\n+\treturn 1;\n+}\n+\n+static void empty_iterator_close(void *arg)\n+{\n+}\n+\n+struct reftable_iterator_vtable empty_vtable = {\n+\t.next = &empty_iterator_next,\n+\t.close = &empty_iterator_close,\n+};\n+\n+void iterator_set_empty(struct reftable_iterator *it)\n+{\n+\tassert(it->ops == NULL);\n+\tit->iter_arg = NULL;\n+\tit->ops = &empty_vtable;\n+}\n+\n+int iterator_next(struct reftable_iterator *it, struct reftable_record *rec)\n+{\n+\treturn it->ops->next(it->iter_arg, rec);\n+}\n+\n+void reftable_iterator_destroy(struct reftable_iterator *it)\n+{\n+\tif (it->ops == NULL) {\n+\t\treturn;\n+\t}\n+\tit->ops->close(it->iter_arg);\n+\tit->ops = NULL;\n+\tFREE_AND_NULL(it->iter_arg);\n+}\n+\n+int reftable_iterator_next_ref(struct reftable_iterator *it,\n+\t\t\t struct reftable_ref_record *ref)\n+{\n+\tstruct reftable_record rec = { 0 };\n+\treftable_record_from_ref(&rec, ref);\n+\treturn iterator_next(it, &rec);\n+}\n+\n+int reftable_iterator_next_log(struct reftable_iterator *it,\n+\t\t\t struct reftable_log_record *log)\n+{\n+\tstruct reftable_record rec = { 0 };\n+\treftable_record_from_log(&rec, log);\n+\treturn iterator_next(it, &rec);\n+}\n+\n+static void filtering_ref_iterator_close(void *iter_arg)\n+{\n+\tstruct filtering_ref_iterator *fri =\n+\t\t(struct filtering_ref_iterator *)iter_arg;\n+\tstrbuf_release(&fri->oid);\n+\treftable_iterator_destroy(&fri->it);\n+}\n+\n+static int filtering_ref_iterator_next(void *iter_arg,\n+\t\t\t\t struct reftable_record *rec)\n+{\n+\tstruct filtering_ref_iterator *fri =\n+\t\t(struct filtering_ref_iterator *)iter_arg;\n+\tstruct reftable_ref_record *ref =\n+\t\t(struct reftable_ref_record *)rec->data;\n+\tint err = 0;\n+\twhile (1) {\n+\t\terr = reftable_iterator_next_ref(&fri->it, ref);\n+\t\tif (err != 0) {\n+\t\t\tbreak;\n+\t\t}\n+\n+\t\tif (fri->double_check) {\n+\t\t\tstruct reftable_iterator it = { 0 };\n+\n+\t\t\terr = reftable_table_seek_ref(&fri->tab, &it,\n+\t\t\t\t\t\t ref->refname);\n+\t\t\tif (err == 0) {\n+\t\t\t\terr = reftable_iterator_next_ref(&it, ref);\n+\t\t\t}\n+\n+\t\t\treftable_iterator_destroy(&it);\n+\n+\t\t\tif (err < 0) {\n+\t\t\t\tbreak;\n+\t\t\t}\n+\n+\t\t\tif (err > 0) {\n+\t\t\t\tcontinue;\n+\t\t\t}\n+\t\t}\n+\n+\t\tif ((ref->target_value != NULL &&\n+\t\t !memcmp(fri->oid.buf, ref->target_value, fri->oid.len)) ||\n+\t\t (ref->value != NULL &&\n+\t\t !memcmp(fri->oid.buf, ref->value, fri->oid.len))) {\n+\t\t\treturn 0;\n+\t\t}\n+\t}\n+\n+\treftable_ref_record_clear(ref);\n+\treturn err;\n+}\n+\n+struct reftable_iterator_vtable filtering_ref_iterator_vtable = {\n+\t.next = &filtering_ref_iterator_next,\n+\t.close = &filtering_ref_iterator_close,\n+};\n+\n+void iterator_from_filtering_ref_iterator(struct reftable_iterator *it,\n+\t\t\t\t\t struct filtering_ref_iterator *fri)\n+{\n+\tassert(it->ops == NULL);\n+\tit->iter_arg = fri;\n+\tit->ops = &filtering_ref_iterator_vtable;\n+}\n+\n+static void indexed_table_ref_iter_close(void *p)\n+{\n+\tstruct indexed_table_ref_iter *it = (struct indexed_table_ref_iter *)p;\n+\tblock_iter_close(&it->cur);\n+\tstrbuf_release(&it->oid);\n+}\n+\n+static int indexed_table_ref_iter_next_block(struct indexed_table_ref_iter *it)\n+{\n+\tuint64_t off;\n+\tint err = 0;\n+\tif (it->offset_idx == it->offset_len) {\n+\t\tit->is_finished = 1;\n+\t\treturn 1;\n+\t}\n+\n+\n+\toff = it->offsets[it->offset_idx++];\n+\t\t\t\t BLOCK_TYPE_REF);\n+\tif (err < 0) {\n+\t\treturn err;\n+\t}\n+\tif (err > 0) {\n+\t\t/* indexed block does not exist. */\n+\t\treturn REFTABLE_FORMAT_ERROR;\n+\t}\n+\treturn 0;\n+}\n+\n+static int indexed_table_ref_iter_next(void *p, struct reftable_record *rec)\n+{\n+\tstruct indexed_table_ref_iter *it = (struct indexed_table_ref_iter *)p;\n+\tstruct reftable_ref_record *ref =\n+\t\t(struct reftable_ref_record *)rec->data;\n+\n+\twhile (1) {\n+\t\tint err = block_iter_next(&it->cur, rec);\n+\t\tif (err < 0) {\n+\t\t\treturn err;\n+\t\t}\n+\n+\t\tif (err > 0) {\n+\t\t\terr = indexed_table_ref_iter_next_block(it);\n+\t\t\tif (err < 0) {\n+\t\t\t\treturn err;\n+\t\t\t}\n+\n+\t\t\tif (it->is_finished) {\n+\t\t\t\treturn 1;\n+\t\t\t}\n+\t\t\tcontinue;\n+\t\t}\n+\n+\t\tif (!memcmp(it->oid.buf, ref->target_value, it->oid.len) ||\n+\t\t !memcmp(it->oid.buf, ref->value, it->oid.len)) {\n+\t\t\treturn 0;\n+\t\t}\n+\t}\n+}\n+\n+int new_indexed_table_ref_iter(struct indexed_table_ref_iter **dest,\n+\t\t\t struct reftable_reader *r, uint8_t *oid,\n+\t\t\t int oid_len, uint64_t *offsets, int offset_len)\n+{\n+\tstruct indexed_table_ref_iter empty = INDEXED_TABLE_REF_ITER_INIT;\n+\tstruct indexed_table_ref_iter *itr =\n+\t\treftable_calloc(sizeof(struct indexed_table_ref_iter));\n+\tint err = 0;\n+\n+\t*itr = empty;\n+\titr->r = r;\n+\n+\titr->offsets = offsets;\n+\titr->offset_len = offset_len;\n+\n+\terr = indexed_table_ref_iter_next_block(itr);\n+\tif (err < 0) {\n+\t\treftable_free(itr);\n+\t} else {\n+\t\t*dest = itr;\n+\t}\n+\treturn err;\n+}\n+\n+struct reftable_iterator_vtable indexed_table_ref_iter_vtable = {\n+\t.next = &indexed_table_ref_iter_next,\n+\t.close = &indexed_table_ref_iter_close,\n+};\n+\n+void iterator_from_indexed_table_ref_iter(struct reftable_iterator *it,\n+\t\t\t\t\t struct indexed_table_ref_iter *itr)\n+{\n+\tassert(it->ops == NULL);\n+\tit->iter_arg = itr;\n+\tit->ops = &indexed_table_ref_iter_vtable;\n+}\ndiff --git a/reftable/iter.h b/reftable/iter.h\nnew file mode 100644\nindex 0000000000..c92a178773\n--- /dev/null\n+++ b/reftable/iter.h\n@@ -0,0 +1,72 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#ifndef ITER_H\n+#define ITER_H\n+\n+#include \"block.h\"\n+#include \"record.h\"\n+#include \"strbuf.h\"\n+\n+struct reftable_iterator_vtable {\n+\tint (*next)(void *iter_arg, struct reftable_record *rec);\n+\tvoid (*close)(void *iter_arg);\n+};\n+\n+void iterator_set_empty(struct reftable_iterator *it);\n+int iterator_next(struct reftable_iterator *it, struct reftable_record *rec);\n+\n+/* Returns true for a zeroed out iterator, such as the one returned from\n+ iterator_destroy. */\n+int iterator_is_null(struct reftable_iterator *it);\n+\n+/* iterator that produces only ref records that point to `oid` */\n+struct filtering_ref_iterator {\n+\tint double_check;\n+\tstruct reftable_table tab;\n+\tstruct strbuf oid;\n+\tstruct reftable_iterator it;\n+};\n+#define FILTERING_REF_ITERATOR_INIT \\\n+\t{ \\\n+\t\t.oid = STRBUF_INIT \\\n+\t}\n+\n+void iterator_from_filtering_ref_iterator(struct reftable_iterator *,\n+\t\t\t\t\t struct filtering_ref_iterator *);\n+\n+/* iterator that produces only ref records that point to `oid`,\n+ but using the object index.\n+ */\n+struct indexed_table_ref_iter {\n+\tstruct strbuf oid;\n+\n+\t/* mutable */\n+\tuint64_t *offsets;\n+\n+\t/* Points to the next offset to read. */\n+\tint offset_idx;\n+\tint offset_len;\n+\tstruct block_iter cur;\n+\tint is_finished;\n+};\n+\n+#define INDEXED_TABLE_REF_ITER_INIT \\\n+\t{ \\\n+\t\t.cur = { .last_key = STRBUF_INIT }, .oid = STRBUF_INIT, \\\n+\t}\n+\n+void iterator_from_indexed_table_ref_iter(struct reftable_iterator *it,\n+\t\t\t\t\t struct indexed_table_ref_iter *itr);\n+int new_indexed_table_ref_iter(struct indexed_table_ref_iter **dest,\n+\t\t\t struct reftable_reader *r, uint8_t *oid,\n+\t\t\t int oid_len, uint64_t *offsets, int offset_len);\n+\n+#endif\nnew file mode 100644\nindex 0000000000..fae2dbb64e\n--- /dev/null\n@@ -0,0 +1,733 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+\n+#include \"system.h\"\n+#include \"block.h\"\n+#include \"constants.h\"\n+#include \"iter.h\"\n+#include \"record.h\"\n+#include \"reftable.h\"\n+#include \"tree.h\"\n+\n+uint64_t block_source_size(struct reftable_block_source *source)\n+{\n+\treturn source->ops->size(source->arg);\n+}\n+\n+\t\t\t struct reftable_block *dest, uint64_t off,\n+\t\t\t uint32_t size)\n+{\n+\tint result = source->ops->read_block(source->arg, dest, off, size);\n+\tdest->source = *source;\n+\treturn result;\n+}\n+\n+void block_source_close(struct reftable_block_source *source)\n+{\n+\tif (source->ops == NULL) {\n+\t\treturn;\n+\t}\n+\n+\tsource->ops->close(source->arg);\n+\tsource->ops = NULL;\n+}\n+\n+{\n+\tswitch (typ) {\n+\tcase BLOCK_TYPE_REF:\n+\t\treturn &r->ref_offsets;\n+\tcase BLOCK_TYPE_LOG:\n+\t\treturn &r->log_offsets;\n+\tcase BLOCK_TYPE_OBJ:\n+\t\treturn &r->obj_offsets;\n+\t}\n+\tabort();\n+}\n+\n+\t\t\t struct reftable_block *dest, uint64_t off,\n+\t\t\t uint32_t sz)\n+{\n+\tif (off >= r->size)\n+\t\treturn 0;\n+\n+\tif (off + sz > r->size) {\n+\t\tsz = r->size - off;\n+\t}\n+\n+\treturn block_source_read_block(&r->source, dest, off, sz);\n+}\n+\n+{\n+\treturn r->hash_id;\n+}\n+\n+{\n+\treturn r->name;\n+}\n+\n+static int parse_footer(struct reftable_reader *r, uint8_t *footer,\n+{\n+\tuint8_t *f = footer;\n+\tuint8_t first_block_typ;\n+\tint err = 0;\n+\tuint32_t computed_crc;\n+\tuint32_t file_crc;\n+\n+\tif (memcmp(f, \"REFT\", 4)) {\n+\t\terr = REFTABLE_FORMAT_ERROR;\n+\t\tgoto done;\n+\t}\n+\tf += 4;\n+\n+\t\terr = REFTABLE_FORMAT_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+\tf++;\n+\tr->block_size = get_be24(f);\n+\n+\tf += 3;\n+\tr->min_update_index = get_be64(f);\n+\tf += 8;\n+\tr->max_update_index = get_be64(f);\n+\tf += 8;\n+\n+\tif (r->version == 1) {\n+\t\tr->hash_id = SHA1_ID;\n+\t} else {\n+\t\tr->hash_id = get_be32(f);\n+\t\tswitch (r->hash_id) {\n+\t\tcase SHA1_ID:\n+\t\t\tbreak;\n+\t\tcase SHA256_ID:\n+\t\t\tbreak;\n+\t\tdefault:\n+\t\t\terr = REFTABLE_FORMAT_ERROR;\n+\t\t\tgoto done;\n+\t\t}\n+\t\tf += 4;\n+\t}\n+\n+\tr->ref_offsets.index_offset = get_be64(f);\n+\tf += 8;\n+\n+\tr->obj_offsets.offset = get_be64(f);\n+\tf += 8;\n+\n+\tr->object_id_len = r->obj_offsets.offset & ((1 << 5) - 1);\n+\tr->obj_offsets.offset >>= 5;\n+\n+\tr->obj_offsets.index_offset = get_be64(f);\n+\tf += 8;\n+\tr->log_offsets.offset = get_be64(f);\n+\tf += 8;\n+\tr->log_offsets.index_offset = get_be64(f);\n+\tf += 8;\n+\n+\tcomputed_crc = crc32(0, footer, f - footer);\n+\tfile_crc = get_be32(f);\n+\tf += 4;\n+\tif (computed_crc != file_crc) {\n+\t\terr = REFTABLE_FORMAT_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+\tr->ref_offsets.is_present = (first_block_typ == BLOCK_TYPE_REF);\n+\tr->ref_offsets.offset = 0;\n+\tr->log_offsets.is_present = (first_block_typ == BLOCK_TYPE_LOG ||\n+\t\t\t\t r->log_offsets.offset > 0);\n+\tr->obj_offsets.is_present = r->obj_offsets.offset > 0;\n+\terr = 0;\n+done:\n+\treturn err;\n+}\n+\n+\t\tconst char *name)\n+{\n+\tstruct reftable_block footer = { 0 };\n+\tstruct reftable_block header = { 0 };\n+\tint err = 0;\n+\n+\n+\t/* Need +1 to read type of first block. */\n+\tif (err != header_size(2) + 1) {\n+\t\terr = REFTABLE_IO_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+\tif (memcmp(header.data, \"REFT\", 4)) {\n+\t\terr = REFTABLE_FORMAT_ERROR;\n+\t\tgoto done;\n+\t}\n+\tif (r->version != 1 && r->version != 2) {\n+\t\terr = REFTABLE_FORMAT_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+\tr->size = block_source_size(source) - footer_size(r->version);\n+\tr->source = *source;\n+\tr->name = xstrdup(name);\n+\tr->hash_id = 0;\n+\n+\terr = block_source_read_block(source, &footer, r->size,\n+\t\t\t\t footer_size(r->version));\n+\tif (err != footer_size(r->version)) {\n+\t\terr = REFTABLE_IO_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+\terr = parse_footer(r, footer.data, header.data);\n+done:\n+\treftable_block_done(&footer);\n+\treturn err;\n+}\n+\n+struct table_iter {\n+\tuint8_t typ;\n+\tuint64_t block_off;\n+\tstruct block_iter bi;\n+\tint is_finished;\n+};\n+#define TABLE_ITER_INIT \\\n+\t{ \\\n+\t\t.bi = {.last_key = STRBUF_INIT } \\\n+\t}\n+\n+static void table_iter_copy_from(struct table_iter *dest,\n+\t\t\t\t struct table_iter *src)\n+{\n+\tdest->r = src->r;\n+\tdest->typ = src->typ;\n+\tdest->block_off = src->block_off;\n+\tdest->is_finished = src->is_finished;\n+\tblock_iter_copy_from(&dest->bi, &src->bi);\n+}\n+\n+static int table_iter_next_in_block(struct table_iter *ti,\n+\t\t\t\t struct reftable_record *rec)\n+{\n+\tint res = block_iter_next(&ti->bi, rec);\n+\tif (res == 0 && reftable_record_type(rec) == BLOCK_TYPE_REF) {\n+\t\t((struct reftable_ref_record *)rec->data)->update_index +=\n+\t\t\tti->r->min_update_index;\n+\t}\n+\n+\treturn res;\n+}\n+\n+static void table_iter_block_done(struct table_iter *ti)\n+{\n+\tif (ti->bi.br == NULL) {\n+\t\treturn;\n+\t}\n+\treftable_block_done(&ti->bi.br->block);\n+\tFREE_AND_NULL(ti->bi.br);\n+\n+\tti->bi.last_key.len = 0;\n+\tti->bi.next_off = 0;\n+}\n+\n+static int32_t extract_block_size(uint8_t *data, uint8_t *typ, uint64_t off,\n+\t\t\t\t int version)\n+{\n+\tint32_t result = 0;\n+\n+\tif (off == 0) {\n+\t}\n+\n+\t*typ = data;\n+\tif (reftable_is_block_type(*typ)) {\n+\t\tresult = get_be24(data + 1);\n+\t}\n+\treturn result;\n+}\n+\n+\t\t\t uint64_t next_off, uint8_t want_typ)\n+{\n+\tint32_t guess_block_size = r->block_size ? r->block_size :\n+\t\t\t\t\t\t\t DEFAULT_BLOCK_SIZE;\n+\tstruct reftable_block block = { 0 };\n+\tuint8_t block_typ = 0;\n+\tint err = 0;\n+\tint32_t block_size = 0;\n+\n+\tif (next_off >= r->size)\n+\t\treturn 1;\n+\n+\terr = reader_get_block(r, &block, next_off, guess_block_size);\n+\tif (err < 0)\n+\t\treturn err;\n+\n+\tblock_size = extract_block_size(block.data, &block_typ, next_off,\n+\t\t\t\t\tr->version);\n+\tif (block_size < 0)\n+\t\treturn block_size;\n+\n+\tif (want_typ != BLOCK_TYPE_ANY && block_typ != want_typ) {\n+\t\treftable_block_done(&block);\n+\t\treturn 1;\n+\t}\n+\n+\tif (block_size > guess_block_size) {\n+\t\treftable_block_done(&block);\n+\t\terr = reader_get_block(r, &block, next_off, block_size);\n+\t\tif (err < 0) {\n+\t\t\treturn err;\n+\t\t}\n+\t}\n+\n+\t\t\t\t hash_size(r->hash_id));\n+}\n+\n+static int table_iter_next_block(struct table_iter *dest,\n+\t\t\t\t struct table_iter *src)\n+{\n+\tuint64_t next_block_off = src->block_off + src->bi.br->full_block_size;\n+\tstruct block_reader br = { 0 };\n+\tint err = 0;\n+\n+\tdest->r = src->r;\n+\tdest->typ = src->typ;\n+\tdest->block_off = next_block_off;\n+\n+\tif (err > 0) {\n+\t\tdest->is_finished = 1;\n+\t\treturn 1;\n+\t}\n+\tif (err != 0)\n+\t\treturn err;\n+\telse {\n+\t\t*brp = br;\n+\n+\t\tdest->is_finished = 0;\n+\t}\n+\treturn 0;\n+}\n+\n+static int table_iter_next(struct table_iter *ti, struct reftable_record *rec)\n+{\n+\tif (reftable_record_type(rec) != ti->typ)\n+\t\treturn REFTABLE_API_ERROR;\n+\n+\twhile (1) {\n+\t\tstruct table_iter next = TABLE_ITER_INIT;\n+\t\tint err = 0;\n+\t\tif (ti->is_finished) {\n+\t\t\treturn 1;\n+\t\t}\n+\n+\t\terr = table_iter_next_in_block(ti, rec);\n+\t\tif (err <= 0) {\n+\t\t\treturn err;\n+\t\t}\n+\n+\t\terr = table_iter_next_block(&next, ti);\n+\t\tif (err != 0) {\n+\t\t\tti->is_finished = 1;\n+\t\t}\n+\t\ttable_iter_block_done(ti);\n+\t\tif (err != 0) {\n+\t\t\treturn err;\n+\t\t}\n+\t\ttable_iter_copy_from(ti, &next);\n+\t\tblock_iter_close(&next.bi);\n+\t}\n+}\n+\n+static int table_iter_next_void(void *ti, struct reftable_record *rec)\n+{\n+\treturn table_iter_next((struct table_iter *)ti, rec);\n+}\n+\n+static void table_iter_close(void *p)\n+{\n+\tstruct table_iter *ti = (struct table_iter *)p;\n+\ttable_iter_block_done(ti);\n+\tblock_iter_close(&ti->bi);\n+}\n+\n+struct reftable_iterator_vtable table_iter_vtable = {\n+\t.next = &table_iter_next_void,\n+\t.close = &table_iter_close,\n+};\n+\n+static void iterator_from_table_iter(struct reftable_iterator *it,\n+\t\t\t\t struct table_iter *ti)\n+{\n+\tassert(it->ops == NULL);\n+\tit->iter_arg = ti;\n+\tit->ops = &table_iter_vtable;\n+}\n+\n+\t\t\t\tstruct table_iter *ti, uint64_t off,\n+\t\t\t\tuint8_t typ)\n+{\n+\tstruct block_reader br = { 0 };\n+\tstruct block_reader *brp = NULL;\n+\n+\tif (err != 0)\n+\t\treturn err;\n+\n+\t*brp = br;\n+\tti->r = r;\n+\tti->block_off = off;\n+\treturn 0;\n+}\n+\n+\t\t\tuint8_t typ, int index)\n+{\n+\tuint64_t off = offs->offset;\n+\tif (index) {\n+\t\toff = offs->index_offset;\n+\t\tif (off == 0) {\n+\t\t\treturn 1;\n+\t\t}\n+\t\ttyp = BLOCK_TYPE_INDEX;\n+\t}\n+\n+\treturn reader_table_iter_at(r, ti, off, typ);\n+}\n+\n+\t\t\t struct reftable_record *want)\n+{\n+\tstruct reftable_record rec =\n+\t\treftable_new_record(reftable_record_type(want));\n+\tstruct strbuf want_key = STRBUF_INIT;\n+\tstruct strbuf got_key = STRBUF_INIT;\n+\tstruct table_iter next = TABLE_ITER_INIT;\n+\tint err = -1;\n+\n+\treftable_record_key(want, &want_key);\n+\n+\twhile (1) {\n+\t\terr = table_iter_next_block(&next, ti);\n+\t\tif (err < 0)\n+\t\t\tgoto done;\n+\n+\t\tif (err > 0) {\n+\t\t\tbreak;\n+\t\t}\n+\n+\t\tif (err < 0)\n+\t\t\tgoto done;\n+\n+\t\tif (strbuf_cmp(&got_key, &want_key) > 0) {\n+\t\t\ttable_iter_block_done(&next);\n+\t\t\tbreak;\n+\t\t}\n+\n+\t\ttable_iter_block_done(ti);\n+\t\ttable_iter_copy_from(ti, &next);\n+\t}\n+\n+\terr = block_iter_seek(&ti->bi, &want_key);\n+\tif (err < 0)\n+\t\tgoto done;\n+\terr = 0;\n+\n+done:\n+\tblock_iter_close(&next.bi);\n+\treftable_record_destroy(&rec);\n+\tstrbuf_release(&want_key);\n+\tstrbuf_release(&got_key);\n+\treturn err;\n+}\n+\n+\t\t\t struct reftable_iterator *it,\n+\t\t\t struct reftable_record *rec)\n+{\n+\tstruct reftable_index_record want_index = { .last_key = STRBUF_INIT };\n+\tstruct reftable_record want_index_rec = { 0 };\n+\tstruct reftable_index_record index_result = { .last_key = STRBUF_INIT };\n+\tstruct reftable_record index_result_rec = { 0 };\n+\tstruct table_iter index_iter = TABLE_ITER_INIT;\n+\tstruct table_iter next = TABLE_ITER_INIT;\n+\tint err = 0;\n+\n+\treftable_record_key(rec, &want_index.last_key);\n+\treftable_record_from_index(&want_index_rec, &want_index);\n+\treftable_record_from_index(&index_result_rec, &index_result);\n+\n+\terr = reader_start(r, &index_iter, reftable_record_type(rec), 1);\n+\tif (err < 0)\n+\t\tgoto done;\n+\n+\terr = reader_seek_linear(r, &index_iter, &want_index_rec);\n+\twhile (1) {\n+\t\terr = table_iter_next(&index_iter, &index_result_rec);\n+\t\ttable_iter_block_done(&index_iter);\n+\t\tif (err != 0)\n+\t\t\tgoto done;\n+\n+\t\terr = reader_table_iter_at(r, &next, index_result.offset, 0);\n+\t\tif (err != 0)\n+\t\t\tgoto done;\n+\n+\t\terr = block_iter_seek(&next.bi, &want_index.last_key);\n+\t\tif (err < 0)\n+\t\t\tgoto done;\n+\n+\t\tif (next.typ == reftable_record_type(rec)) {\n+\t\t\terr = 0;\n+\t\t\tbreak;\n+\t\t}\n+\n+\t\tif (next.typ != BLOCK_TYPE_INDEX) {\n+\t\t\terr = REFTABLE_FORMAT_ERROR;\n+\t\t\tbreak;\n+\t\t}\n+\n+\t\ttable_iter_copy_from(&index_iter, &next);\n+\t}\n+\n+\tif (err == 0) {\n+\t\tstruct table_iter empty = TABLE_ITER_INIT;\n+\t\tstruct table_iter *malloced =\n+\t\t\treftable_calloc(sizeof(struct table_iter));\n+\t\t*malloced = empty;\n+\t\ttable_iter_copy_from(malloced, &next);\n+\t\titerator_from_table_iter(it, malloced);\n+\t}\n+done:\n+\tblock_iter_close(&next.bi);\n+\ttable_iter_close(&index_iter);\n+\treftable_record_clear(&want_index_rec);\n+\treftable_record_clear(&index_result_rec);\n+\treturn err;\n+}\n+\n+\t\t\t\tstruct reftable_iterator *it,\n+\t\t\t\tstruct reftable_record *rec)\n+{\n+\tuint64_t idx = offs->index_offset;\n+\tstruct table_iter ti = TABLE_ITER_INIT;\n+\tint err = 0;\n+\tif (idx > 0)\n+\n+\terr = reader_start(r, &ti, reftable_record_type(rec), 0);\n+\tif (err < 0)\n+\t\treturn err;\n+\terr = reader_seek_linear(r, &ti, rec);\n+\tif (err < 0)\n+\t\treturn err;\n+\telse {\n+\t\tstruct table_iter *p =\n+\t\t\treftable_malloc(sizeof(struct table_iter));\n+\t\t*p = ti;\n+\t\titerator_from_table_iter(it, p);\n+\t}\n+\n+\treturn 0;\n+}\n+\n+\t\tstruct reftable_record *rec)\n+{\n+\tuint8_t typ = reftable_record_type(rec);\n+\n+\tif (!offs->is_present) {\n+\t\titerator_set_empty(it);\n+\t\treturn 0;\n+\t}\n+\n+}\n+\n+\t\t\t struct reftable_iterator *it, const char *name)\n+{\n+\tstruct reftable_ref_record ref = {\n+\t\t.refname = (char *)name,\n+\t};\n+\tstruct reftable_record rec = { 0 };\n+\treftable_record_from_ref(&rec, &ref);\n+}\n+\n+\t\t\t\tstruct reftable_iterator *it, const char *name,\n+\t\t\t\tuint64_t update_index)\n+{\n+\tstruct reftable_log_record log = {\n+\t\t.refname = (char *)name,\n+\t\t.update_index = update_index,\n+\t};\n+\tstruct reftable_record rec = { 0 };\n+\treftable_record_from_log(&rec, &log);\n+}\n+\n+\t\t\t struct reftable_iterator *it, const char *name)\n+{\n+\tuint64_t max = ~((uint64_t)0);\n+\treturn reftable_reader_seek_log_at(r, it, name, max);\n+}\n+\n+{\n+\tblock_source_close(&r->source);\n+\tFREE_AND_NULL(r->name);\n+}\n+\n+\t\t\tstruct reftable_block_source *src, char const *name)\n+{\n+\tint err = init_reader(rd, src, name);\n+\tif (err == 0) {\n+\t\t*p = rd;\n+\t} else {\n+\t\tblock_source_close(src);\n+\t\treftable_free(rd);\n+\t}\n+\treturn err;\n+}\n+\n+{\n+\treftable_free(r);\n+}\n+\n+\t\t\t\t\t struct reftable_iterator *it,\n+\t\t\t\t\t uint8_t *oid)\n+{\n+\tstruct reftable_obj_record want = {\n+\t\t.hash_prefix = oid,\n+\t\t.hash_prefix_len = r->object_id_len,\n+\t};\n+\tstruct reftable_record want_rec = { 0 };\n+\tstruct reftable_iterator oit = { 0 };\n+\tstruct reftable_obj_record got = { 0 };\n+\tstruct reftable_record got_rec = { 0 };\n+\tint err = 0;\n+\tstruct indexed_table_ref_iter *itr = NULL;\n+\n+\t/* Look through the reverse index. */\n+\treftable_record_from_obj(&want_rec, &want);\n+\terr = reader_seek(r, &oit, &want_rec);\n+\tif (err != 0)\n+\t\tgoto done;\n+\n+\t/* read out the reftable_obj_record */\n+\treftable_record_from_obj(&got_rec, &got);\n+\terr = iterator_next(&oit, &got_rec);\n+\tif (err < 0)\n+\t\tgoto done;\n+\n+\tif (err > 0 ||\n+\t memcmp(want.hash_prefix, got.hash_prefix, r->object_id_len)) {\n+\t\t/* didn't find it; return empty iterator */\n+\t\titerator_set_empty(it);\n+\t\terr = 0;\n+\t\tgoto done;\n+\t}\n+\n+\terr = new_indexed_table_ref_iter(&itr, r, oid, hash_size(r->hash_id),\n+\t\t\t\t\t got.offsets, got.offset_len);\n+\tif (err < 0)\n+\t\tgoto done;\n+\tgot.offsets = NULL;\n+\titerator_from_indexed_table_ref_iter(it, itr);\n+\n+done:\n+\treftable_iterator_destroy(&oit);\n+\treftable_record_clear(&got_rec);\n+\treturn err;\n+}\n+\n+\t\t\t\t\t struct reftable_iterator *it,\n+\t\t\t\t\t uint8_t *oid)\n+{\n+\tstruct table_iter ti_empty = TABLE_ITER_INIT;\n+\tstruct table_iter *ti = reftable_calloc(sizeof(struct table_iter));\n+\tstruct filtering_ref_iterator *filter = NULL;\n+\tstruct filtering_ref_iterator empty = FILTERING_REF_ITERATOR_INIT;\n+\tint oid_len = hash_size(r->hash_id);\n+\tint err;\n+\n+\t*ti = ti_empty;\n+\terr = reader_start(r, ti, BLOCK_TYPE_REF, 0);\n+\tif (err < 0) {\n+\t\treftable_free(ti);\n+\t\treturn err;\n+\t}\n+\n+\tfilter = reftable_malloc(sizeof(struct filtering_ref_iterator));\n+\t*filter = empty;\n+\n+\tfilter->double_check = 0;\n+\titerator_from_table_iter(&filter->it, ti);\n+\n+\titerator_from_filtering_ref_iterator(it, filter);\n+\treturn 0;\n+}\n+\n+\t\t\t struct reftable_iterator *it, uint8_t *oid)\n+{\n+\tif (r->obj_offsets.is_present)\n+}\n+\n+{\n+\treturn r->max_update_index;\n+}\n+\n+{\n+\treturn r->min_update_index;\n+}\nnew file mode 100644\nindex 0000000000..8170258881\n--- /dev/null\n@@ -0,0 +1,78 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+\n+#include \"block.h\"\n+#include \"record.h\"\n+#include \"reftable.h\"\n+\n+uint64_t block_source_size(struct reftable_block_source *source);\n+\n+\t\t\t struct reftable_block *dest, uint64_t off,\n+\t\t\t uint32_t size);\n+void block_source_close(struct reftable_block_source *source);\n+\n+/* metadata for a block type */\n+\tint is_present;\n+\tuint64_t offset;\n+\tuint64_t index_offset;\n+};\n+\n+/* The state for reading a reftable file. */\n+\t/* for convience, associate a name with the instance. */\n+\tchar *name;\n+\tstruct reftable_block_source source;\n+\n+\t/* Size of the file, excluding the footer. */\n+\tuint64_t size;\n+\n+\t/* 'sha1' for SHA1, 's256' for SHA-256 */\n+\tuint32_t hash_id;\n+\n+\tuint32_t block_size;\n+\tuint64_t min_update_index;\n+\tuint64_t max_update_index;\n+\t/* Length of the OID keys in the 'o' section */\n+\tint object_id_len;\n+\tint version;\n+\n+};\n+\n+\t\tconst char *name);\n+\t\tstruct reftable_record *rec);\n+\n+\t\t\t uint64_t next_off, uint8_t want_typ);\n+\n+/* generic interface to reftables */\n+struct reftable_table_vtable {\n+\tint (*seek_record)(void *tab, struct reftable_iterator *it,\n+\t\t\t struct reftable_record *);\n+\tuint32_t (*hash_id)(void *tab);\n+\tuint64_t (*min_update_index)(void *tab);\n+\tuint64_t (*max_update_index)(void *tab);\n+};\n+\n+int reftable_table_seek_record(struct reftable_table *tab,\n+\t\t\t struct reftable_iterator *it,\n+\t\t\t struct reftable_record *rec);\n+\n+#endif\ndiff --git a/reftable/reftable.c b/reftable/reftable.c\nnew file mode 100644\nindex 0000000000..1425aef6f2\n--- /dev/null\n+++ b/reftable/reftable.c\n@@ -0,0 +1,104 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"reftable.h\"\n+#include \"record.h\"\n+\n+static int reftable_reader_seek_void(void *tab, struct reftable_iterator *it,\n+\t\t\t\t struct reftable_record *rec)\n+{\n+}\n+\n+{\n+}\n+\n+{\n+}\n+\n+{\n+}\n+\n+static struct reftable_table_vtable reader_vtable = {\n+};\n+\n+int reftable_table_seek_ref(struct reftable_table *tab,\n+\t\t\t struct reftable_iterator *it, const char *name)\n+{\n+\tstruct reftable_ref_record ref = {\n+\t\t.refname = (char *)name,\n+\t};\n+\tstruct reftable_record rec = { 0 };\n+\treftable_record_from_ref(&rec, &ref);\n+\treturn tab->ops->seek_record(tab->table_arg, it, &rec);\n+}\n+\n+{\n+\tassert(tab->ops == NULL);\n+}\n+\n+int reftable_table_read_ref(struct reftable_table *tab, const char *name,\n+\t\t\t struct reftable_ref_record *ref)\n+{\n+\tstruct reftable_iterator it = { 0 };\n+\tint err = reftable_table_seek_ref(tab, &it, name);\n+\tif (err)\n+\t\tgoto done;\n+\n+\terr = reftable_iterator_next_ref(&it, ref);\n+\tif (err)\n+\t\tgoto done;\n+\n+\tif (strcmp(ref->refname, name) ||\n+\t reftable_ref_record_is_deletion(ref)) {\n+\t\treftable_ref_record_clear(ref);\n+\t\terr = 1;\n+\t\tgoto done;\n+\t}\n+\n+done:\n+\treftable_iterator_destroy(&it);\n+\treturn err;\n+}\n+\n+int reftable_table_seek_record(struct reftable_table *tab,\n+\t\t\t struct reftable_iterator *it,\n+\t\t\t struct reftable_record *rec)\n+{\n+\treturn tab->ops->seek_record(tab->table_arg, it, rec);\n+}\n+\n+uint64_t reftable_table_max_update_index(struct reftable_table *tab)\n+{\n+\treturn tab->ops->max_update_index(tab->table_arg);\n+}\n+\n+uint64_t reftable_table_min_update_index(struct reftable_table *tab)\n+{\n+\treturn tab->ops->min_update_index(tab->table_arg);\n+}\n+\n+uint32_t reftable_table_hash_id(struct reftable_table *tab)\n+{\n+\treturn tab->ops->hash_id(tab->table_arg);\n+}\n--\n\n• ```* [PATCH 11/13] reftable: file level tests\n2020-09-16 19:10 [PATCH 00/13] reftable library Han-Wen Nienhuys via GitGitGadget\n` (9 preceding siblings ...)\n2020-09-16 19:10 ` [PATCH 10/13] reftable: read \" Han-Wen Nienhuys via GitGitGadget\n@ 2020-09-16 19:10 ` Han-Wen Nienhuys via GitGitGadget\n2020-09-16 19:10 ` [PATCH 12/13] reftable: rest of library Han-Wen Nienhuys via GitGitGadget\n` (2 subsequent siblings)\n13 siblings, 0 replies; 251+ messages in thread\nFrom: Han-Wen Nienhuys via GitGitGadget @ 2020-09-16 19:10 UTC (permalink / raw)\nTo: git; +Cc: Han-Wen Nienhuys, Han-Wen Nienhuys\n\n---\nMakefile | 1 +\nreftable/reftable_test.c | 585 +++++++++++++++++++++++++++++++++++++++\nt/helper/test-reftable.c | 1 +\n3 files changed, 587 insertions(+)\ncreate mode 100644 reftable/reftable_test.c\n\ndiff --git a/Makefile b/Makefile\nindex 275fc4227c..22dd31e7ff 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -2360,6 +2360,7 @@ REFTABLE_OBJS += reftable/zlib-compat.o\n\nREFTABLE_TEST_OBJS += reftable/block_test.o\nREFTABLE_TEST_OBJS += reftable/record_test.o\n+REFTABLE_TEST_OBJS += reftable/reftable_test.o\nREFTABLE_TEST_OBJS += reftable/strbuf_test.o\nREFTABLE_TEST_OBJS += reftable/test_framework.o\nREFTABLE_TEST_OBJS += reftable/tree_test.o\ndiff --git a/reftable/reftable_test.c b/reftable/reftable_test.c\nnew file mode 100644\nindex 0000000000..73efeaf523\n--- /dev/null\n+++ b/reftable/reftable_test.c\n@@ -0,0 +1,585 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"reftable.h\"\n+\n+#include \"system.h\"\n+\n+#include \"basics.h\"\n+#include \"block.h\"\n+#include \"blocksource.h\"\n+#include \"constants.h\"\n+#include \"record.h\"\n+#include \"test_framework.h\"\n+#include \"reftable-tests.h\"\n+\n+static const int update_index = 5;\n+\n+static void test_buffer(void)\n+{\n+\tstruct strbuf buf = STRBUF_INIT;\n+\tstruct reftable_block_source source = { NULL };\n+\tstruct reftable_block out = { 0 };\n+\tint n;\n+\tuint8_t in[] = \"hello\";\n+\tblock_source_from_strbuf(&source, &buf);\n+\tassert(block_source_size(&source) == 6);\n+\tn = block_source_read_block(&source, &out, 0, sizeof(in));\n+\tassert(n == sizeof(in));\n+\tassert(!memcmp(in, out.data, n));\n+\treftable_block_done(&out);\n+\n+\tn = block_source_read_block(&source, &out, 1, 2);\n+\tassert(n == 2);\n+\tassert(!memcmp(out.data, \"el\", 2));\n+\n+\treftable_block_done(&out);\n+\tblock_source_close(&source);\n+\tstrbuf_release(&buf);\n+}\n+\n+static void write_table(char ***names, struct strbuf *buf, int N,\n+\t\t\tint block_size, uint32_t hash_id)\n+{\n+\tstruct reftable_write_options opts = {\n+\t\t.block_size = block_size,\n+\t\t.hash_id = hash_id,\n+\t};\n+\tstruct reftable_writer *w =\n+\tstruct reftable_ref_record ref = { 0 };\n+\tint i = 0, n;\n+\tstruct reftable_log_record log = { 0 };\n+\tconst struct reftable_stats *stats = NULL;\n+\t*names = reftable_calloc(sizeof(char *) * (N + 1));\n+\treftable_writer_set_limits(w, update_index, update_index);\n+\tfor (i = 0; i < N; i++) {\n+\t\tuint8_t hash[SHA256_SIZE] = { 0 };\n+\t\tchar name;\n+\t\tint n;\n+\n+\t\tset_test_hash(hash, i);\n+\n+\n+\t\tref.refname = name;\n+\t\tref.value = hash;\n+\t\tref.update_index = update_index;\n+\t\t(*names)[i] = xstrdup(name);\n+\n+\t\tassert(n == 0);\n+\t}\n+\n+\tfor (i = 0; i < N; i++) {\n+\t\tuint8_t hash[SHA256_SIZE] = { 0 };\n+\t\tchar name;\n+\t\tint n;\n+\n+\t\tset_test_hash(hash, i);\n+\n+\n+\t\tlog.refname = name;\n+\t\tlog.new_hash = hash;\n+\t\tlog.update_index = update_index;\n+\t\tlog.message = \"message\";\n+\n+\t\tassert(n == 0);\n+\t}\n+\n+\tn = reftable_writer_close(w);\n+\tassert(n == 0);\n+\n+\tstats = writer_stats(w);\n+\tfor (i = 0; i < stats->ref_stats.blocks; i++) {\n+\t\tint off = i * opts.block_size;\n+\t\tif (off == 0) {\n+\t\t\toff = header_size((hash_id == SHA256_ID) ? 2 : 1);\n+\t\t}\n+\t\tassert(buf->buf[off] == 'r');\n+\t}\n+\n+\tassert(stats->log_stats.blocks > 0);\n+\treftable_writer_free(w);\n+}\n+\n+static void test_log_buffer_size(void)\n+{\n+\tstruct strbuf buf = STRBUF_INIT;\n+\tstruct reftable_write_options opts = {\n+\t\t.block_size = 4096,\n+\t};\n+\tint err;\n+\tstruct reftable_log_record log = {\n+\t\t.name = \"Han-Wen Nienhuys\",\n+\t\t.tz_offset = 100,\n+\t\t.time = 0x5e430672,\n+\t\t.update_index = 0xa,\n+\t\t.message = \"commit: 9\\n\",\n+\t};\n+\tstruct reftable_writer *w =\n+\n+\t/* This tests buffer extension for log compression. Must use a random\n+\t hash, to ensure that the compressed part is larger than the original.\n+\t*/\n+\tuint8_t hash1[SHA1_SIZE], hash2[SHA1_SIZE];\n+\tfor (int i = 0; i < SHA1_SIZE; i++) {\n+\t\thash1[i] = (uint8_t)(rand() % 256);\n+\t\thash2[i] = (uint8_t)(rand() % 256);\n+\t}\n+\tlog.old_hash = hash1;\n+\tlog.new_hash = hash2;\n+\treftable_writer_set_limits(w, update_index, update_index);\n+\tassert_err(err);\n+\terr = reftable_writer_close(w);\n+\tassert_err(err);\n+\treftable_writer_free(w);\n+\tstrbuf_release(&buf);\n+}\n+\n+{\n+\tint N = 2;\n+\tchar **names = reftable_calloc(sizeof(char *) * (N + 1));\n+\tint err;\n+\tstruct reftable_write_options opts = {\n+\t\t.block_size = 256,\n+\t};\n+\tstruct reftable_ref_record ref = { 0 };\n+\tint i = 0;\n+\tstruct reftable_log_record log = { 0 };\n+\tint n;\n+\tstruct reftable_iterator it = { 0 };\n+\tstruct reftable_reader rd = { 0 };\n+\tstruct reftable_block_source source = { 0 };\n+\tstruct strbuf buf = STRBUF_INIT;\n+\tstruct reftable_writer *w =\n+\tconst struct reftable_stats *stats = NULL;\n+\treftable_writer_set_limits(w, 0, N);\n+\tfor (i = 0; i < N; i++) {\n+\t\tchar name;\n+\t\tstruct reftable_ref_record ref = { 0 };\n+\t\tsnprintf(name, sizeof(name), \"b%02d%0*d\", i, 130, 7);\n+\t\tnames[i] = xstrdup(name);\n+\t\tref.refname = name;\n+\t\tref.update_index = i;\n+\n+\t\tassert_err(err);\n+\t}\n+\tfor (i = 0; i < N; i++) {\n+\t\tuint8_t hash1[SHA1_SIZE], hash2[SHA1_SIZE];\n+\t\tstruct reftable_log_record log = { 0 };\n+\t\tset_test_hash(hash1, i);\n+\t\tset_test_hash(hash2, i + 1);\n+\n+\t\tlog.refname = names[i];\n+\t\tlog.update_index = i;\n+\t\tlog.old_hash = hash1;\n+\t\tlog.new_hash = hash2;\n+\n+\t\tassert_err(err);\n+\t}\n+\n+\tn = reftable_writer_close(w);\n+\tassert(n == 0);\n+\n+\tstats = writer_stats(w);\n+\tassert(stats->log_stats.blocks > 0);\n+\treftable_writer_free(w);\n+\tw = NULL;\n+\n+\tblock_source_from_strbuf(&source, &buf);\n+\n+\terr = init_reader(&rd, &source, \"file.log\");\n+\tassert_err(err);\n+\n+\terr = reftable_reader_seek_ref(&rd, &it, names[N - 1]);\n+\tassert_err(err);\n+\n+\terr = reftable_iterator_next_ref(&it, &ref);\n+\tassert_err(err);\n+\n+\t/* end of iteration. */\n+\terr = reftable_iterator_next_ref(&it, &ref);\n+\tassert(0 < err);\n+\n+\treftable_iterator_destroy(&it);\n+\treftable_ref_record_clear(&ref);\n+\n+\terr = reftable_reader_seek_log(&rd, &it, \"\");\n+\tassert_err(err);\n+\n+\ti = 0;\n+\twhile (1) {\n+\t\tint err = reftable_iterator_next_log(&it, &log);\n+\t\tif (err > 0) {\n+\t\t\tbreak;\n+\t\t}\n+\n+\t\tassert_err(err);\n+\t\tassert_streq(names[i], log.refname);\n+\t\tassert(i == log.update_index);\n+\t\ti++;\n+\t\treftable_log_record_clear(&log);\n+\t}\n+\n+\tassert(i == N);\n+\treftable_iterator_destroy(&it);\n+\n+\t/* cleanup. */\n+\tstrbuf_release(&buf);\n+\tfree_names(names);\n+}\n+\n+{\n+\tchar **names;\n+\tstruct strbuf buf = STRBUF_INIT;\n+\tint N = 50;\n+\tstruct reftable_iterator it = { 0 };\n+\tstruct reftable_block_source source = { 0 };\n+\tstruct reftable_reader rd = { 0 };\n+\tint err = 0;\n+\tint j = 0;\n+\n+\twrite_table(&names, &buf, N, 256, SHA1_ID);\n+\n+\tblock_source_from_strbuf(&source, &buf);\n+\n+\terr = init_reader(&rd, &source, \"file.ref\");\n+\tassert_err(err);\n+\n+\terr = reftable_reader_seek_ref(&rd, &it, \"\");\n+\tassert_err(err);\n+\n+\twhile (1) {\n+\t\tstruct reftable_ref_record ref = { 0 };\n+\t\tint r = reftable_iterator_next_ref(&it, &ref);\n+\t\tassert(r >= 0);\n+\t\tif (r > 0) {\n+\t\t\tbreak;\n+\t\t}\n+\t\tassert(0 == strcmp(names[j], ref.refname));\n+\t\tassert(update_index == ref.update_index);\n+\n+\t\tj++;\n+\t\treftable_ref_record_clear(&ref);\n+\t}\n+\tassert(j == N);\n+\treftable_iterator_destroy(&it);\n+\tstrbuf_release(&buf);\n+\tfree_names(names);\n+\n+}\n+\n+static void test_table_write_small_table(void)\n+{\n+\tchar **names;\n+\tstruct strbuf buf = STRBUF_INIT;\n+\tint N = 1;\n+\twrite_table(&names, &buf, N, 4096, SHA1_ID);\n+\tassert(buf.len < 200);\n+\tstrbuf_release(&buf);\n+\tfree_names(names);\n+}\n+\n+{\n+\tchar **names;\n+\tstruct strbuf buf = STRBUF_INIT;\n+\tint N = 50;\n+\tstruct reftable_reader rd = { 0 };\n+\tstruct reftable_block_source source = { 0 };\n+\tint err;\n+\tint i;\n+\tstruct reftable_log_record log = { 0 };\n+\tstruct reftable_iterator it = { 0 };\n+\n+\twrite_table(&names, &buf, N, 256, SHA1_ID);\n+\n+\tblock_source_from_strbuf(&source, &buf);\n+\n+\terr = init_reader(&rd, &source, \"file.ref\");\n+\tassert_err(err);\n+\n+\terr = reftable_reader_seek_ref(&rd, &it, names);\n+\tassert_err(err);\n+\n+\terr = reftable_iterator_next_log(&it, &log);\n+\tassert(err == REFTABLE_API_ERROR);\n+\n+\tstrbuf_release(&buf);\n+\tfor (i = 0; i < N; i++) {\n+\t\treftable_free(names[i]);\n+\t}\n+\treftable_iterator_destroy(&it);\n+\treftable_free(names);\n+\tstrbuf_release(&buf);\n+}\n+\n+static void test_table_read_write_seek(int index, int hash_id)\n+{\n+\tchar **names;\n+\tstruct strbuf buf = STRBUF_INIT;\n+\tint N = 50;\n+\tstruct reftable_reader rd = { 0 };\n+\tstruct reftable_block_source source = { 0 };\n+\tint err;\n+\tint i = 0;\n+\n+\tstruct reftable_iterator it = { 0 };\n+\tstruct strbuf pastLast = STRBUF_INIT;\n+\tstruct reftable_ref_record ref = { 0 };\n+\n+\twrite_table(&names, &buf, N, 256, hash_id);\n+\n+\tblock_source_from_strbuf(&source, &buf);\n+\n+\terr = init_reader(&rd, &source, \"file.ref\");\n+\tassert_err(err);\n+\n+\tif (!index) {\n+\t\trd.ref_offsets.index_offset = 0;\n+\t} else {\n+\t\tassert(rd.ref_offsets.index_offset > 0);\n+\t}\n+\n+\tfor (i = 1; i < N; i++) {\n+\t\tint err = reftable_reader_seek_ref(&rd, &it, names[i]);\n+\t\tassert_err(err);\n+\t\terr = reftable_iterator_next_ref(&it, &ref);\n+\t\tassert_err(err);\n+\t\tassert(0 == strcmp(names[i], ref.refname));\n+\t\tassert(i == ref.value);\n+\n+\t\treftable_ref_record_clear(&ref);\n+\t\treftable_iterator_destroy(&it);\n+\t}\n+\n+\n+\terr = reftable_reader_seek_ref(&rd, &it, pastLast.buf);\n+\tif (err == 0) {\n+\t\tstruct reftable_ref_record ref = { 0 };\n+\t\tint err = reftable_iterator_next_ref(&it, &ref);\n+\t\tassert(err > 0);\n+\t} else {\n+\t\tassert(err > 0);\n+\t}\n+\n+\tstrbuf_release(&pastLast);\n+\treftable_iterator_destroy(&it);\n+\n+\tstrbuf_release(&buf);\n+\tfor (i = 0; i < N; i++) {\n+\t\treftable_free(names[i]);\n+\t}\n+\treftable_free(names);\n+}\n+\n+{\n+}\n+\n+{\n+}\n+\n+{\n+}\n+\n+static void test_table_refs_for(int indexed)\n+{\n+\tint N = 50;\n+\tchar **want_names = reftable_calloc(sizeof(char *) * (N + 1));\n+\tint want_names_len = 0;\n+\tuint8_t want_hash[SHA1_SIZE];\n+\n+\tstruct reftable_write_options opts = {\n+\t\t.block_size = 256,\n+\t};\n+\tstruct reftable_ref_record ref = { 0 };\n+\tint i = 0;\n+\tint n;\n+\tint err;\n+\tstruct reftable_block_source source = { 0 };\n+\n+\tstruct strbuf buf = STRBUF_INIT;\n+\tstruct reftable_writer *w =\n+\n+\tstruct reftable_iterator it = { 0 };\n+\tint j;\n+\n+\tset_test_hash(want_hash, 4);\n+\n+\tfor (i = 0; i < N; i++) {\n+\t\tuint8_t hash[SHA1_SIZE];\n+\t\tchar fill = { 0 };\n+\t\tchar name;\n+\t\tuint8_t hash1[SHA1_SIZE];\n+\t\tuint8_t hash2[SHA1_SIZE];\n+\t\tstruct reftable_ref_record ref = { 0 };\n+\n+\t\tmemset(hash, i, sizeof(hash));\n+\t\tmemset(fill, 'x', 50);\n+\t\t/* Put the variable part in the start */\n+\t\tsnprintf(name, sizeof(name), \"br%02d%s\", i, fill);\n+\t\tname = 0;\n+\t\tref.refname = name;\n+\n+\t\tset_test_hash(hash1, i / 4);\n+\t\tset_test_hash(hash2, 3 + i / 4);\n+\t\tref.value = hash1;\n+\t\tref.target_value = hash2;\n+\n+\t\t/* 80 bytes / entry, so 3 entries per block. Yields 17\n+\t\t */\n+\t\t/* blocks. */\n+\t\tassert(n == 0);\n+\n+\t\tif (!memcmp(hash1, want_hash, SHA1_SIZE) ||\n+\t\t !memcmp(hash2, want_hash, SHA1_SIZE)) {\n+\t\t\twant_names[want_names_len++] = xstrdup(name);\n+\t\t}\n+\t}\n+\n+\tn = reftable_writer_close(w);\n+\tassert(n == 0);\n+\n+\treftable_writer_free(w);\n+\tw = NULL;\n+\n+\tblock_source_from_strbuf(&source, &buf);\n+\n+\terr = init_reader(&rd, &source, \"file.ref\");\n+\tassert_err(err);\n+\tif (!indexed) {\n+\t\trd.obj_offsets.is_present = 0;\n+\t}\n+\n+\terr = reftable_reader_seek_ref(&rd, &it, \"\");\n+\tassert_err(err);\n+\treftable_iterator_destroy(&it);\n+\n+\terr = reftable_reader_refs_for(&rd, &it, want_hash);\n+\tassert_err(err);\n+\n+\tj = 0;\n+\twhile (1) {\n+\t\tint err = reftable_iterator_next_ref(&it, &ref);\n+\t\tassert(err >= 0);\n+\t\tif (err > 0) {\n+\t\t\tbreak;\n+\t\t}\n+\n+\t\tassert(j < want_names_len);\n+\t\tassert(0 == strcmp(ref.refname, want_names[j]));\n+\t\tj++;\n+\t\treftable_ref_record_clear(&ref);\n+\t}\n+\tassert(j == want_names_len);\n+\n+\tstrbuf_release(&buf);\n+\tfree_names(want_names);\n+\treftable_iterator_destroy(&it);\n+}\n+\n+static void test_table_refs_for_no_index(void)\n+{\n+\ttest_table_refs_for(0);\n+}\n+\n+static void test_table_refs_for_obj_index(void)\n+{\n+\ttest_table_refs_for(1);\n+}\n+\n+static void test_table_empty(void)\n+{\n+\tstruct reftable_write_options opts = { 0 };\n+\tstruct strbuf buf = STRBUF_INIT;\n+\tstruct reftable_writer *w =\n+\tstruct reftable_block_source source = { 0 };\n+\tstruct reftable_reader *rd = NULL;\n+\tstruct reftable_ref_record rec = { 0 };\n+\tstruct reftable_iterator it = { 0 };\n+\tint err;\n+\n+\treftable_writer_set_limits(w, 1, 1);\n+\n+\terr = reftable_writer_close(w);\n+\tassert(err == REFTABLE_EMPTY_TABLE_ERROR);\n+\treftable_writer_free(w);\n+\n+\tassert(buf.len == header_size(1) + footer_size(1));\n+\n+\tblock_source_from_strbuf(&source, &buf);\n+\n+\terr = reftable_new_reader(&rd, &source, \"filename\");\n+\tassert_err(err);\n+\n+\terr = reftable_reader_seek_ref(rd, &it, \"\");\n+\tassert_err(err);\n+\n+\terr = reftable_iterator_next_ref(&it, &rec);\n+\tassert(err > 0);\n+\n+\treftable_iterator_destroy(&it);\n+\tstrbuf_release(&buf);\n+}\n+\n+int reftable_test_main(int argc, const char *argv[])\n+{\n+\t\t &test_table_write_small_table);\n+\t\t &test_table_refs_for_no_index);\n+\t\t &test_table_refs_for_obj_index);\n+\treturn test_main(argc, argv);\n+}\ndiff --git a/t/helper/test-reftable.c b/t/helper/test-reftable.c\nindex 9c4e0f42dc..2273fdfe39 100644\n--- a/t/helper/test-reftable.c\n+++ b/t/helper/test-reftable.c\n@@ -5,6 +5,7 @@ int cmd__reftable(int argc, const char **argv)\n{\nblock_test_main(argc, argv);\nrecord_test_main(argc, argv);\n+\treftable_test_main(argc, argv);\nstrbuf_test_main(argc, argv);\ntree_test_main(argc, argv);\nreturn 0;\n--\n\n• ```* [PATCH 12/13] reftable: rest of library\n2020-09-16 19:10 [PATCH 00/13] reftable library Han-Wen Nienhuys via GitGitGadget\n` (10 preceding siblings ...)\n2020-09-16 19:10 ` [PATCH 11/13] reftable: file level tests Han-Wen Nienhuys via GitGitGadget\n@ 2020-09-16 19:10 ` Han-Wen Nienhuys via GitGitGadget\n2020-09-16 19:10 ` [PATCH 13/13] reftable: \"test-tool dump-reftable\" command Han-Wen Nienhuys via GitGitGadget\n2020-10-01 16:10 ` [PATCH v2 00/13] reftable library Han-Wen Nienhuys via GitGitGadget\n13 siblings, 0 replies; 251+ messages in thread\nFrom: Han-Wen Nienhuys via GitGitGadget @ 2020-09-16 19:10 UTC (permalink / raw)\nTo: git; +Cc: Han-Wen Nienhuys, Han-Wen Nienhuys\n\nThis will be further split up once preceding commits have passed review.\n\n---\nMakefile | 8 +-\nreftable/VERSION | 1 +\nreftable/dump.c | 212 +++++++\nreftable/merged.c | 358 +++++++++++\nreftable/merged.h | 39 ++\nreftable/merged_test.c | 331 +++++++++++\nreftable/pq.c | 115 ++++\nreftable/pq.h | 34 ++\nreftable/refname.c | 209 +++++++\nreftable/refname.h | 38 ++\nreftable/refname_test.c | 100 ++++\nreftable/stack.c | 1224 ++++++++++++++++++++++++++++++++++++++\nreftable/stack.h | 50 ++\nreftable/stack_test.c | 787 ++++++++++++++++++++++++\nreftable/update.sh | 22 +\nt/helper/test-reftable.c | 3 +\n16 files changed, 3530 insertions(+), 1 deletion(-)\ncreate mode 100644 reftable/VERSION\ncreate mode 100644 reftable/dump.c\ncreate mode 100644 reftable/merged.c\ncreate mode 100644 reftable/merged.h\ncreate mode 100644 reftable/merged_test.c\ncreate mode 100644 reftable/pq.c\ncreate mode 100644 reftable/pq.h\ncreate mode 100644 reftable/refname.c\ncreate mode 100644 reftable/refname.h\ncreate mode 100644 reftable/refname_test.c\ncreate mode 100644 reftable/stack.c\ncreate mode 100644 reftable/stack.h\ncreate mode 100644 reftable/stack_test.c\ncreate mode 100755 reftable/update.sh\n\ndiff --git a/Makefile b/Makefile\nindex 22dd31e7ff..6652259baf 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -2347,12 +2347,16 @@ XDIFF_OBJS += xdiff/xutils.o\nREFTABLE_OBJS += reftable/basics.o\nREFTABLE_OBJS += reftable/block.o\nREFTABLE_OBJS += reftable/blocksource.o\n-REFTABLE_OBJS += reftable/publicbasics.o\nREFTABLE_OBJS += reftable/compat.o\nREFTABLE_OBJS += reftable/iter.o\n+REFTABLE_OBJS += reftable/merged.o\n+REFTABLE_OBJS += reftable/pq.o\n+REFTABLE_OBJS += reftable/publicbasics.o\nREFTABLE_OBJS += reftable/record.o\n+REFTABLE_OBJS += reftable/refname.o\nREFTABLE_OBJS += reftable/reftable.o\n+REFTABLE_OBJS += reftable/stack.o\nREFTABLE_OBJS += reftable/strbuf.o\nREFTABLE_OBJS += reftable/tree.o\nREFTABLE_OBJS += reftable/writer.o\n@@ -2360,7 +2364,9 @@ REFTABLE_OBJS += reftable/zlib-compat.o\n\nREFTABLE_TEST_OBJS += reftable/block_test.o\nREFTABLE_TEST_OBJS += reftable/record_test.o\n+REFTABLE_TEST_OBJS += reftable/refname_test.o\nREFTABLE_TEST_OBJS += reftable/reftable_test.o\n+REFTABLE_TEST_OBJS += reftable/stack_test.o\nREFTABLE_TEST_OBJS += reftable/strbuf_test.o\nREFTABLE_TEST_OBJS += reftable/test_framework.o\nREFTABLE_TEST_OBJS += reftable/tree_test.o\ndiff --git a/reftable/VERSION b/reftable/VERSION\nnew file mode 100644\nindex 0000000000..7553c395eb\n--- /dev/null\n+++ b/reftable/VERSION\n@@ -0,0 +1 @@\ndiff --git a/reftable/dump.c b/reftable/dump.c\nnew file mode 100644\nindex 0000000000..00b444e8c9\n--- /dev/null\n+++ b/reftable/dump.c\n@@ -0,0 +1,212 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include <stddef.h>\n+#include <stdio.h>\n+#include <stdlib.h>\n+#include <unistd.h>\n+#include <string.h>\n+\n+#include \"reftable.h\"\n+#include \"reftable-tests.h\"\n+\n+static uint32_t hash_id;\n+\n+static int dump_table(const char *tablename)\n+{\n+\tstruct reftable_block_source src = { 0 };\n+\tint err = reftable_block_source_from_file(&src, tablename);\n+\tstruct reftable_iterator it = { 0 };\n+\tstruct reftable_ref_record ref = { 0 };\n+\tstruct reftable_log_record log = { 0 };\n+\tstruct reftable_reader *r = NULL;\n+\n+\tif (err < 0)\n+\t\treturn err;\n+\n+\terr = reftable_new_reader(&r, &src, tablename);\n+\tif (err < 0)\n+\t\treturn err;\n+\n+\terr = reftable_reader_seek_ref(r, &it, \"\");\n+\tif (err < 0) {\n+\t\treturn err;\n+\t}\n+\n+\twhile (1) {\n+\t\terr = reftable_iterator_next_ref(&it, &ref);\n+\t\tif (err > 0) {\n+\t\t\tbreak;\n+\t\t}\n+\t\tif (err < 0) {\n+\t\t\treturn err;\n+\t\t}\n+\t\treftable_ref_record_print(&ref, hash_id);\n+\t}\n+\treftable_iterator_destroy(&it);\n+\treftable_ref_record_clear(&ref);\n+\n+\terr = reftable_reader_seek_log(r, &it, \"\");\n+\tif (err < 0) {\n+\t\treturn err;\n+\t}\n+\twhile (1) {\n+\t\terr = reftable_iterator_next_log(&it, &log);\n+\t\tif (err > 0) {\n+\t\t\tbreak;\n+\t\t}\n+\t\tif (err < 0) {\n+\t\t\treturn err;\n+\t\t}\n+\t\treftable_log_record_print(&log, hash_id);\n+\t}\n+\treftable_iterator_destroy(&it);\n+\treftable_log_record_clear(&log);\n+\n+\treturn 0;\n+}\n+\n+static int compact_stack(const char *stackdir)\n+{\n+\tstruct reftable_stack *stack = NULL;\n+\tstruct reftable_write_options cfg = {};\n+\n+\tint err = reftable_new_stack(&stack, stackdir, cfg);\n+\tif (err < 0)\n+\t\tgoto done;\n+\n+\terr = reftable_stack_compact_all(stack, NULL);\n+\tif (err < 0)\n+\t\tgoto done;\n+done:\n+\tif (stack != NULL) {\n+\t\treftable_stack_destroy(stack);\n+\t}\n+\treturn err;\n+}\n+\n+static int dump_stack(const char *stackdir)\n+{\n+\tstruct reftable_stack *stack = NULL;\n+\tstruct reftable_write_options cfg = {};\n+\tstruct reftable_iterator it = { 0 };\n+\tstruct reftable_ref_record ref = { 0 };\n+\tstruct reftable_log_record log = { 0 };\n+\tstruct reftable_merged_table *merged = NULL;\n+\n+\tint err = reftable_new_stack(&stack, stackdir, cfg);\n+\tif (err < 0)\n+\t\treturn err;\n+\n+\tmerged = reftable_stack_merged_table(stack);\n+\n+\terr = reftable_merged_table_seek_ref(merged, &it, \"\");\n+\tif (err < 0) {\n+\t\treturn err;\n+\t}\n+\n+\twhile (1) {\n+\t\terr = reftable_iterator_next_ref(&it, &ref);\n+\t\tif (err > 0) {\n+\t\t\tbreak;\n+\t\t}\n+\t\tif (err < 0) {\n+\t\t\treturn err;\n+\t\t}\n+\t\treftable_ref_record_print(&ref, hash_id);\n+\t}\n+\treftable_iterator_destroy(&it);\n+\treftable_ref_record_clear(&ref);\n+\n+\terr = reftable_merged_table_seek_log(merged, &it, \"\");\n+\tif (err < 0) {\n+\t\treturn err;\n+\t}\n+\twhile (1) {\n+\t\terr = reftable_iterator_next_log(&it, &log);\n+\t\tif (err > 0) {\n+\t\t\tbreak;\n+\t\t}\n+\t\tif (err < 0) {\n+\t\t\treturn err;\n+\t\t}\n+\t\treftable_log_record_print(&log, hash_id);\n+\t}\n+\treftable_iterator_destroy(&it);\n+\treftable_log_record_clear(&log);\n+\n+\treftable_stack_destroy(stack);\n+\treturn 0;\n+}\n+\n+static void print_help(void)\n+{\n+\tprintf(\"usage: dump [-cst] arg\\n\\n\"\n+\t \"options: \\n\"\n+\t \" -c compact\\n\"\n+\t \" -t dump table\\n\"\n+\t \" -s dump stack\\n\"\n+\t \" -h this help\\n\"\n+\t \" -2 use SHA256\\n\"\n+\t \"\\n\");\n+}\n+\n+int reftable_dump_main(int argc, char *const *argv)\n+{\n+\tint err = 0;\n+\tint opt;\n+\tint opt_dump_table = 0;\n+\tint opt_dump_stack = 0;\n+\tint opt_compact = 0;\n+\tconst char *arg = NULL;\n+\twhile ((opt = getopt(argc, argv, \"2chts\")) != -1) {\n+\t\tswitch (opt) {\n+\t\tcase '2':\n+\t\t\thash_id = 0x73323536;\n+\t\t\tbreak;\n+\t\tcase 't':\n+\t\t\topt_dump_table = 1;\n+\t\t\tbreak;\n+\t\tcase 's':\n+\t\t\topt_dump_stack = 1;\n+\t\t\tbreak;\n+\t\tcase 'c':\n+\t\t\topt_compact = 1;\n+\t\t\tbreak;\n+\t\tcase '?':\n+\t\tcase 'h':\n+\t\t\tprint_help();\n+\t\t\treturn 2;\n+\t\t\tbreak;\n+\t\t}\n+\t}\n+\n+\tif (argv[optind] == NULL) {\n+\t\tfprintf(stderr, \"need argument\\n\");\n+\t\tprint_help();\n+\t\treturn 2;\n+\t}\n+\n+\targ = argv[optind];\n+\n+\tif (opt_dump_table) {\n+\t\terr = dump_table(arg);\n+\t} else if (opt_dump_stack) {\n+\t\terr = dump_stack(arg);\n+\t} else if (opt_compact) {\n+\t\terr = compact_stack(arg);\n+\t}\n+\n+\tif (err < 0) {\n+\t\tfprintf(stderr, \"%s: %s: %s\\n\", argv, arg,\n+\t\t\treftable_error_str(err));\n+\t\treturn 1;\n+\t}\n+\treturn 0;\n+}\ndiff --git a/reftable/merged.c b/reftable/merged.c\nnew file mode 100644\nindex 0000000000..22b071cb5d\n--- /dev/null\n+++ b/reftable/merged.c\n@@ -0,0 +1,358 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"merged.h\"\n+\n+#include \"constants.h\"\n+#include \"iter.h\"\n+#include \"pq.h\"\n+#include \"record.h\"\n+#include \"reftable.h\"\n+#include \"system.h\"\n+\n+static int merged_iter_init(struct merged_iter *mi)\n+{\n+\tint i = 0;\n+\tfor (i = 0; i < mi->stack_len; i++) {\n+\t\tstruct reftable_record rec = reftable_new_record(mi->typ);\n+\t\tint err = iterator_next(&mi->stack[i], &rec);\n+\t\tif (err < 0) {\n+\t\t\treturn err;\n+\t\t}\n+\n+\t\tif (err > 0) {\n+\t\t\treftable_iterator_destroy(&mi->stack[i]);\n+\t\t\treftable_record_destroy(&rec);\n+\t\t} else {\n+\t\t\tstruct pq_entry e = {\n+\t\t\t\t.rec = rec,\n+\t\t\t\t.index = i,\n+\t\t\t};\n+\t\t}\n+\t}\n+\n+\treturn 0;\n+}\n+\n+static void merged_iter_close(void *p)\n+{\n+\tstruct merged_iter *mi = (struct merged_iter *)p;\n+\tint i = 0;\n+\tmerged_iter_pqueue_clear(&mi->pq);\n+\tfor (i = 0; i < mi->stack_len; i++) {\n+\t\treftable_iterator_destroy(&mi->stack[i]);\n+\t}\n+\treftable_free(mi->stack);\n+}\n+\n+\t\t\t\t\t size_t idx)\n+{\n+\tstruct reftable_record rec = reftable_new_record(mi->typ);\n+\tstruct pq_entry e = {\n+\t\t.rec = rec,\n+\t\t.index = idx,\n+\t};\n+\tint err = iterator_next(&mi->stack[idx], &rec);\n+\tif (err < 0)\n+\t\treturn err;\n+\n+\tif (err > 0) {\n+\t\treftable_iterator_destroy(&mi->stack[idx]);\n+\t\treftable_record_destroy(&rec);\n+\t\treturn 0;\n+\t}\n+\n+\treturn 0;\n+}\n+\n+static int merged_iter_advance_subiter(struct merged_iter *mi, size_t idx)\n+{\n+\tif (iterator_is_null(&mi->stack[idx]))\n+\t\treturn 0;\n+}\n+\n+static int merged_iter_next_entry(struct merged_iter *mi,\n+\t\t\t\t struct reftable_record *rec)\n+{\n+\tstruct strbuf entry_key = STRBUF_INIT;\n+\tstruct pq_entry entry = { 0 };\n+\tint err = 0;\n+\n+\tif (merged_iter_pqueue_is_empty(mi->pq))\n+\t\treturn 1;\n+\n+\tentry = merged_iter_pqueue_remove(&mi->pq);\n+\tif (err < 0)\n+\t\treturn err;\n+\n+\t/*\n+\t One can also use reftable as datacenter-local storage, where the ref\n+\t database is maintained in globally consistent database (eg.\n+\t CockroachDB or Spanner). In this scenario, replication delays together\n+\t with compaction may cause newer tables to contain older entries. In\n+\t such a deployment, the loop below must be changed to collect all\n+\t entries for the same key, and return new the newest one.\n+\t*/\n+\treftable_record_key(&entry.rec, &entry_key);\n+\twhile (!merged_iter_pqueue_is_empty(mi->pq)) {\n+\t\tstruct pq_entry top = merged_iter_pqueue_top(mi->pq);\n+\t\tstruct strbuf k = STRBUF_INIT;\n+\t\tint err = 0, cmp = 0;\n+\n+\t\treftable_record_key(&top.rec, &k);\n+\n+\t\tcmp = strbuf_cmp(&k, &entry_key);\n+\t\tstrbuf_release(&k);\n+\n+\t\tif (cmp > 0) {\n+\t\t\tbreak;\n+\t\t}\n+\n+\t\tmerged_iter_pqueue_remove(&mi->pq);\n+\t\tif (err < 0) {\n+\t\t\treturn err;\n+\t\t}\n+\t\treftable_record_destroy(&top.rec);\n+\t}\n+\n+\treftable_record_copy_from(rec, &entry.rec, hash_size(mi->hash_id));\n+\treftable_record_destroy(&entry.rec);\n+\tstrbuf_release(&entry_key);\n+\treturn 0;\n+}\n+\n+static int merged_iter_next(struct merged_iter *mi, struct reftable_record *rec)\n+{\n+\twhile (1) {\n+\t\tint err = merged_iter_next_entry(mi, rec);\n+\t\tif (err == 0 && mi->suppress_deletions &&\n+\t\t reftable_record_is_deletion(rec)) {\n+\t\t\tcontinue;\n+\t\t}\n+\n+\t\treturn err;\n+\t}\n+}\n+\n+static int merged_iter_next_void(void *p, struct reftable_record *rec)\n+{\n+\tstruct merged_iter *mi = (struct merged_iter *)p;\n+\tif (merged_iter_pqueue_is_empty(mi->pq))\n+\t\treturn 1;\n+\n+\treturn merged_iter_next(mi, rec);\n+}\n+\n+struct reftable_iterator_vtable merged_iter_vtable = {\n+\t.next = &merged_iter_next_void,\n+\t.close = &merged_iter_close,\n+};\n+\n+static void iterator_from_merged_iter(struct reftable_iterator *it,\n+\t\t\t\t struct merged_iter *mi)\n+{\n+\tassert(it->ops == NULL);\n+\tit->iter_arg = mi;\n+\tit->ops = &merged_iter_vtable;\n+}\n+\n+int reftable_new_merged_table(struct reftable_merged_table **dest,\n+\t\t\t struct reftable_table *stack, int n,\n+\t\t\t uint32_t hash_id)\n+{\n+\tstruct reftable_merged_table *m = NULL;\n+\tuint64_t last_max = 0;\n+\tuint64_t first_min = 0;\n+\tint i = 0;\n+\tfor (i = 0; i < n; i++) {\n+\t\tuint64_t min = reftable_table_min_update_index(&stack[i]);\n+\t\tuint64_t max = reftable_table_max_update_index(&stack[i]);\n+\n+\t\tif (reftable_table_hash_id(&stack[i]) != hash_id) {\n+\t\t\treturn REFTABLE_FORMAT_ERROR;\n+\t\t}\n+\t\tif (i == 0 || min < first_min) {\n+\t\t\tfirst_min = min;\n+\t\t}\n+\t\tif (i == 0 || max > last_max) {\n+\t\t\tlast_max = max;\n+\t\t}\n+\t}\n+\n+\tm = (struct reftable_merged_table *)reftable_calloc(\n+\t\tsizeof(struct reftable_merged_table));\n+\tm->stack = stack;\n+\tm->stack_len = n;\n+\tm->min = first_min;\n+\tm->max = last_max;\n+\tm->hash_id = hash_id;\n+\t*dest = m;\n+\treturn 0;\n+}\n+\n+/* clears the list of subtable, without affecting the readers themselves. */\n+void merged_table_clear(struct reftable_merged_table *mt)\n+{\n+\tFREE_AND_NULL(mt->stack);\n+\tmt->stack_len = 0;\n+}\n+\n+void reftable_merged_table_free(struct reftable_merged_table *mt)\n+{\n+\tif (mt == NULL) {\n+\t\treturn;\n+\t}\n+\tmerged_table_clear(mt);\n+\treftable_free(mt);\n+}\n+\n+uint64_t\n+reftable_merged_table_max_update_index(struct reftable_merged_table *mt)\n+{\n+\treturn mt->max;\n+}\n+\n+uint64_t\n+reftable_merged_table_min_update_index(struct reftable_merged_table *mt)\n+{\n+\treturn mt->min;\n+}\n+\n+int merged_table_seek_record(struct reftable_merged_table *mt,\n+\t\t\t struct reftable_iterator *it,\n+\t\t\t struct reftable_record *rec)\n+{\n+\tstruct reftable_iterator *iters = reftable_calloc(\n+\t\tsizeof(struct reftable_iterator) * mt->stack_len);\n+\tstruct merged_iter merged = {\n+\t\t.stack = iters,\n+\t\t.typ = reftable_record_type(rec),\n+\t\t.hash_id = mt->hash_id,\n+\t\t.suppress_deletions = mt->suppress_deletions,\n+\t};\n+\tint n = 0;\n+\tint err = 0;\n+\tint i = 0;\n+\tfor (i = 0; i < mt->stack_len && err == 0; i++) {\n+\t\tint e = reftable_table_seek_record(&mt->stack[i], &iters[n],\n+\t\t\t\t\t\t rec);\n+\t\tif (e < 0) {\n+\t\t\terr = e;\n+\t\t}\n+\t\tif (e == 0) {\n+\t\t\tn++;\n+\t\t}\n+\t}\n+\tif (err < 0) {\n+\t\tint i = 0;\n+\t\tfor (i = 0; i < n; i++) {\n+\t\t\treftable_iterator_destroy(&iters[i]);\n+\t\t}\n+\t\treftable_free(iters);\n+\t\treturn err;\n+\t}\n+\n+\tmerged.stack_len = n;\n+\terr = merged_iter_init(&merged);\n+\tif (err < 0) {\n+\t\tmerged_iter_close(&merged);\n+\t\treturn err;\n+\t} else {\n+\t\tstruct merged_iter *p =\n+\t\t\treftable_malloc(sizeof(struct merged_iter));\n+\t\t*p = merged;\n+\t\titerator_from_merged_iter(it, p);\n+\t}\n+\treturn 0;\n+}\n+\n+int reftable_merged_table_seek_ref(struct reftable_merged_table *mt,\n+\t\t\t\t struct reftable_iterator *it,\n+\t\t\t\t const char *name)\n+{\n+\tstruct reftable_ref_record ref = {\n+\t\t.refname = (char *)name,\n+\t};\n+\tstruct reftable_record rec = { 0 };\n+\treftable_record_from_ref(&rec, &ref);\n+\treturn merged_table_seek_record(mt, it, &rec);\n+}\n+\n+int reftable_merged_table_seek_log_at(struct reftable_merged_table *mt,\n+\t\t\t\t struct reftable_iterator *it,\n+\t\t\t\t const char *name, uint64_t update_index)\n+{\n+\tstruct reftable_log_record log = {\n+\t\t.refname = (char *)name,\n+\t\t.update_index = update_index,\n+\t};\n+\tstruct reftable_record rec = { 0 };\n+\treftable_record_from_log(&rec, &log);\n+\treturn merged_table_seek_record(mt, it, &rec);\n+}\n+\n+int reftable_merged_table_seek_log(struct reftable_merged_table *mt,\n+\t\t\t\t struct reftable_iterator *it,\n+\t\t\t\t const char *name)\n+{\n+\tuint64_t max = ~((uint64_t)0);\n+\treturn reftable_merged_table_seek_log_at(mt, it, name, max);\n+}\n+\n+uint32_t reftable_merged_table_hash_id(struct reftable_merged_table *mt)\n+{\n+\treturn mt->hash_id;\n+}\n+\n+static int reftable_merged_table_seek_void(void *tab,\n+\t\t\t\t\t struct reftable_iterator *it,\n+\t\t\t\t\t struct reftable_record *rec)\n+{\n+\treturn merged_table_seek_record((struct reftable_merged_table *)tab, it,\n+\t\t\t\t\trec);\n+}\n+\n+static uint32_t reftable_merged_table_hash_id_void(void *tab)\n+{\n+\treturn reftable_merged_table_hash_id(\n+\t\t(struct reftable_merged_table *)tab);\n+}\n+\n+static uint64_t reftable_merged_table_min_update_index_void(void *tab)\n+{\n+\treturn reftable_merged_table_min_update_index(\n+\t\t(struct reftable_merged_table *)tab);\n+}\n+\n+static uint64_t reftable_merged_table_max_update_index_void(void *tab)\n+{\n+\treturn reftable_merged_table_max_update_index(\n+\t\t(struct reftable_merged_table *)tab);\n+}\n+\n+static struct reftable_table_vtable merged_table_vtable = {\n+\t.seek_record = reftable_merged_table_seek_void,\n+\t.hash_id = reftable_merged_table_hash_id_void,\n+\t.min_update_index = reftable_merged_table_min_update_index_void,\n+\t.max_update_index = reftable_merged_table_max_update_index_void,\n+};\n+\n+void reftable_table_from_merged_table(struct reftable_table *tab,\n+\t\t\t\t struct reftable_merged_table *merged)\n+{\n+\tassert(tab->ops == NULL);\n+\ttab->ops = &merged_table_vtable;\n+\ttab->table_arg = merged;\n+}\ndiff --git a/reftable/merged.h b/reftable/merged.h\nnew file mode 100644\nindex 0000000000..66a1d71830\n--- /dev/null\n+++ b/reftable/merged.h\n@@ -0,0 +1,39 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#ifndef MERGED_H\n+#define MERGED_H\n+\n+#include \"pq.h\"\n+#include \"reftable.h\"\n+\n+struct reftable_merged_table {\n+\tstruct reftable_table *stack;\n+\tsize_t stack_len;\n+\tuint32_t hash_id;\n+\tint suppress_deletions;\n+\n+\tuint64_t min;\n+\tuint64_t max;\n+};\n+\n+struct merged_iter {\n+\tstruct reftable_iterator *stack;\n+\tuint32_t hash_id;\n+\tsize_t stack_len;\n+\tuint8_t typ;\n+\tint suppress_deletions;\n+\tstruct merged_iter_pqueue pq;\n+};\n+\n+void merged_table_clear(struct reftable_merged_table *mt);\n+int merged_table_seek_record(struct reftable_merged_table *mt,\n+\t\t\t struct reftable_iterator *it,\n+\t\t\t struct reftable_record *rec);\n+\n+#endif\ndiff --git a/reftable/merged_test.c b/reftable/merged_test.c\nnew file mode 100644\nindex 0000000000..18a0fe1dac\n--- /dev/null\n+++ b/reftable/merged_test.c\n@@ -0,0 +1,331 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"merged.h\"\n+\n+#include \"system.h\"\n+\n+#include \"basics.h\"\n+#include \"blocksource.h\"\n+#include \"constants.h\"\n+#include \"pq.h\"\n+#include \"record.h\"\n+#include \"reftable.h\"\n+#include \"test_framework.h\"\n+#include \"reftable-tests.h\"\n+\n+static void test_pq(void)\n+{\n+\tchar *names = { 0 };\n+\tint N = ARRAY_SIZE(names) - 1;\n+\n+\tstruct merged_iter_pqueue pq = { 0 };\n+\tconst char *last = NULL;\n+\n+\tint i = 0;\n+\tfor (i = 0; i < N; i++) {\n+\t\tchar name;\n+\t\tsnprintf(name, sizeof(name), \"%02d\", i);\n+\t\tnames[i] = xstrdup(name);\n+\t}\n+\n+\ti = 1;\n+\tdo {\n+\t\tstruct reftable_record rec =\n+\t\t\treftable_new_record(BLOCK_TYPE_REF);\n+\t\tstruct pq_entry e = { 0 };\n+\n+\t\treftable_record_as_ref(&rec)->refname = names[i];\n+\t\te.rec = rec;\n+\t\tmerged_iter_pqueue_check(pq);\n+\t\ti = (i * 7) % N;\n+\t} while (i != 1);\n+\n+\twhile (!merged_iter_pqueue_is_empty(pq)) {\n+\t\tstruct pq_entry e = merged_iter_pqueue_remove(&pq);\n+\t\tstruct reftable_ref_record *ref =\n+\t\t\treftable_record_as_ref(&e.rec);\n+\n+\t\tmerged_iter_pqueue_check(pq);\n+\n+\t\tif (last != NULL) {\n+\t\t\tassert(strcmp(last, ref->refname) < 0);\n+\t\t}\n+\t\tlast = ref->refname;\n+\t\tref->refname = NULL;\n+\t\treftable_free(ref);\n+\t}\n+\n+\tfor (i = 0; i < N; i++) {\n+\t\treftable_free(names[i]);\n+\t}\n+\n+\tmerged_iter_pqueue_clear(&pq);\n+}\n+\n+static void write_test_table(struct strbuf *buf,\n+\t\t\t struct reftable_ref_record refs[], int n)\n+{\n+\tint min = 0xffffffff;\n+\tint max = 0;\n+\tint i = 0;\n+\tint err;\n+\n+\tstruct reftable_write_options opts = {\n+\t\t.block_size = 256,\n+\t};\n+\tstruct reftable_writer *w = NULL;\n+\tfor (i = 0; i < n; i++) {\n+\t\tuint64_t ui = refs[i].update_index;\n+\t\tif (ui > max) {\n+\t\t\tmax = ui;\n+\t\t}\n+\t\tif (ui < min) {\n+\t\t\tmin = ui;\n+\t\t}\n+\t}\n+\n+\tw = reftable_new_writer(&strbuf_add_void, buf, &opts);\n+\treftable_writer_set_limits(w, min, max);\n+\n+\tfor (i = 0; i < n; i++) {\n+\t\tuint64_t before = refs[i].update_index;\n+\t\tint n = reftable_writer_add_ref(w, &refs[i]);\n+\t\tassert(n == 0);\n+\t\tassert(before == refs[i].update_index);\n+\t}\n+\n+\terr = reftable_writer_close(w);\n+\tassert_err(err);\n+\n+\treftable_writer_free(w);\n+}\n+\n+static struct reftable_merged_table *\n+merged_table_from_records(struct reftable_ref_record **refs,\n+\t\t\t struct reftable_block_source **source,\n+\t\t\t struct strbuf *buf, int n)\n+{\n+\tint i = 0;\n+\tstruct reftable_merged_table *mt = NULL;\n+\tint err;\n+\tstruct reftable_table *tabs =\n+\t\treftable_calloc(n * sizeof(struct reftable_table));\n+\t*source = reftable_calloc(n * sizeof(**source));\n+\tfor (i = 0; i < n; i++) {\n+\t\twrite_test_table(&buf[i], refs[i], sizes[i]);\n+\t\tblock_source_from_strbuf(&(*source)[i], &buf[i]);\n+\n+\t\t\t\t\t \"name\");\n+\t\tassert_err(err);\n+\t}\n+\n+\terr = reftable_new_merged_table(&mt, tabs, n, SHA1_ID);\n+\tassert_err(err);\n+\treturn mt;\n+}\n+\n+{\n+\tint i = 0;\n+\tfor (; i < n; i++)\n+}\n+\n+static void test_merged_between(void)\n+{\n+\tuint8_t hash1[SHA1_SIZE] = { 1, 2, 3, 0 };\n+\n+\tstruct reftable_ref_record r1[] = { {\n+\t\t.refname = \"b\",\n+\t\t.update_index = 1,\n+\t\t.value = hash1,\n+\t} };\n+\tstruct reftable_ref_record r2[] = { {\n+\t\t.refname = \"a\",\n+\t\t.update_index = 2,\n+\t} };\n+\n+\tstruct reftable_ref_record *refs[] = { r1, r2 };\n+\tint sizes[] = { 1, 1 };\n+\tstruct strbuf bufs = { STRBUF_INIT, STRBUF_INIT };\n+\tstruct reftable_block_source *bs = NULL;\n+\tstruct reftable_merged_table *mt =\n+\t\tmerged_table_from_records(refs, &bs, &readers, sizes, bufs, 2);\n+\tint i;\n+\tstruct reftable_ref_record ref = { 0 };\n+\tstruct reftable_iterator it = { 0 };\n+\tint err = reftable_merged_table_seek_ref(mt, &it, \"a\");\n+\tassert_err(err);\n+\n+\terr = reftable_iterator_next_ref(&it, &ref);\n+\tassert_err(err);\n+\tassert(ref.update_index == 2);\n+\treftable_ref_record_clear(&ref);\n+\treftable_iterator_destroy(&it);\n+\treftable_merged_table_free(mt);\n+\tfor (i = 0; i < ARRAY_SIZE(bufs); i++) {\n+\t\tstrbuf_release(&bufs[i]);\n+\t}\n+\treftable_free(bs);\n+}\n+\n+static void test_merged(void)\n+{\n+\tuint8_t hash1[SHA1_SIZE] = { 1 };\n+\tuint8_t hash2[SHA1_SIZE] = { 2 };\n+\tstruct reftable_ref_record r1[] = { {\n+\t\t\t\t\t\t .refname = \"a\",\n+\t\t\t\t\t\t .update_index = 1,\n+\t\t\t\t\t\t .value = hash1,\n+\t\t\t\t\t },\n+\t\t\t\t\t {\n+\t\t\t\t\t\t .refname = \"b\",\n+\t\t\t\t\t\t .update_index = 1,\n+\t\t\t\t\t\t .value = hash1,\n+\t\t\t\t\t },\n+\t\t\t\t\t {\n+\t\t\t\t\t\t .refname = \"c\",\n+\t\t\t\t\t\t .update_index = 1,\n+\t\t\t\t\t\t .value = hash1,\n+\t\t\t\t\t } };\n+\tstruct reftable_ref_record r2[] = { {\n+\t\t.refname = \"a\",\n+\t\t.update_index = 2,\n+\t} };\n+\tstruct reftable_ref_record r3[] = {\n+\t\t{\n+\t\t\t.refname = \"c\",\n+\t\t\t.update_index = 3,\n+\t\t\t.value = hash2,\n+\t\t},\n+\t\t{\n+\t\t\t.refname = \"d\",\n+\t\t\t.update_index = 3,\n+\t\t\t.value = hash1,\n+\t\t},\n+\t};\n+\n+\tstruct reftable_ref_record want[] = {\n+\t\tr2,\n+\t\tr1,\n+\t\tr3,\n+\t\tr3,\n+\t};\n+\n+\tstruct reftable_ref_record *refs[] = { r1, r2, r3 };\n+\tint sizes = { 3, 1, 2 };\n+\tstruct strbuf bufs = { STRBUF_INIT, STRBUF_INIT, STRBUF_INIT };\n+\tstruct reftable_block_source *bs = NULL;\n+\tstruct reftable_merged_table *mt =\n+\t\tmerged_table_from_records(refs, &bs, &readers, sizes, bufs, 3);\n+\n+\tstruct reftable_iterator it = { 0 };\n+\tint err = reftable_merged_table_seek_ref(mt, &it, \"a\");\n+\tstruct reftable_ref_record *out = NULL;\n+\tsize_t len = 0;\n+\tsize_t cap = 0;\n+\tint i = 0;\n+\n+\tassert_err(err);\n+\twhile (len < 100) { /* cap loops/recursion. */\n+\t\tstruct reftable_ref_record ref = { 0 };\n+\t\tint err = reftable_iterator_next_ref(&it, &ref);\n+\t\tif (err > 0) {\n+\t\t\tbreak;\n+\t\t}\n+\t\tif (len == cap) {\n+\t\t\tcap = 2 * cap + 1;\n+\t\t\tout = reftable_realloc(\n+\t\t\t\tout, sizeof(struct reftable_ref_record) * cap);\n+\t\t}\n+\t\tout[len++] = ref;\n+\t}\n+\treftable_iterator_destroy(&it);\n+\n+\tassert(ARRAY_SIZE(want) == len);\n+\tfor (i = 0; i < len; i++) {\n+\t\tassert(reftable_ref_record_equal(&want[i], &out[i], SHA1_SIZE));\n+\t}\n+\tfor (i = 0; i < len; i++) {\n+\t\treftable_ref_record_clear(&out[i]);\n+\t}\n+\treftable_free(out);\n+\n+\tfor (i = 0; i < 3; i++) {\n+\t\tstrbuf_release(&bufs[i]);\n+\t}\n+\treftable_merged_table_free(mt);\n+\treftable_free(bs);\n+}\n+\n+static void test_default_write_opts(void)\n+{\n+\tstruct reftable_write_options opts = { 0 };\n+\tstruct strbuf buf = STRBUF_INIT;\n+\tstruct reftable_writer *w =\n+\n+\tstruct reftable_ref_record rec = {\n+\t\t.refname = \"master\",\n+\t\t.update_index = 1,\n+\t};\n+\tint err;\n+\tstruct reftable_block_source source = { 0 };\n+\tstruct reftable_table *tab = reftable_calloc(sizeof(*tab) * 1);\n+\tuint32_t hash_id;\n+\tstruct reftable_reader *rd = NULL;\n+\tstruct reftable_merged_table *merged = NULL;\n+\n+\treftable_writer_set_limits(w, 1, 1);\n+\n+\tassert_err(err);\n+\n+\terr = reftable_writer_close(w);\n+\tassert_err(err);\n+\treftable_writer_free(w);\n+\n+\tblock_source_from_strbuf(&source, &buf);\n+\n+\terr = reftable_new_reader(&rd, &source, \"filename\");\n+\tassert_err(err);\n+\n+\tassert(hash_id == SHA1_ID);\n+\n+\terr = reftable_new_merged_table(&merged, tab, 1, SHA1_ID);\n+\tassert_err(err);\n+\n+\treftable_merged_table_free(merged);\n+\tstrbuf_release(&buf);\n+}\n+\n+/* XXX test refs_for(oid) */\n+\n+int merged_test_main(int argc, const char *argv[])\n+{\n+\treturn test_main(argc, argv);\n+}\ndiff --git a/reftable/pq.c b/reftable/pq.c\nnew file mode 100644\nindex 0000000000..5fa1b5f437\n--- /dev/null\n+++ b/reftable/pq.c\n@@ -0,0 +1,115 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"pq.h\"\n+\n+#include \"reftable.h\"\n+#include \"system.h\"\n+#include \"basics.h\"\n+\n+int pq_less(struct pq_entry a, struct pq_entry b)\n+{\n+\tstruct strbuf ak = STRBUF_INIT;\n+\tstruct strbuf bk = STRBUF_INIT;\n+\tint cmp = 0;\n+\treftable_record_key(&a.rec, &ak);\n+\treftable_record_key(&b.rec, &bk);\n+\n+\tcmp = strbuf_cmp(&ak, &bk);\n+\n+\tstrbuf_release(&ak);\n+\tstrbuf_release(&bk);\n+\n+\tif (cmp == 0)\n+\t\treturn a.index > b.index;\n+\n+\treturn cmp < 0;\n+}\n+\n+struct pq_entry merged_iter_pqueue_top(struct merged_iter_pqueue pq)\n+{\n+\treturn pq.heap;\n+}\n+\n+int merged_iter_pqueue_is_empty(struct merged_iter_pqueue pq)\n+{\n+\treturn pq.len == 0;\n+}\n+\n+void merged_iter_pqueue_check(struct merged_iter_pqueue pq)\n+{\n+\tint i = 0;\n+\tfor (i = 1; i < pq.len; i++) {\n+\t\tint parent = (i - 1) / 2;\n+\n+\t\tassert(pq_less(pq.heap[parent], pq.heap[i]));\n+\t}\n+}\n+\n+struct pq_entry merged_iter_pqueue_remove(struct merged_iter_pqueue *pq)\n+{\n+\tint i = 0;\n+\tstruct pq_entry e = pq->heap;\n+\tpq->heap = pq->heap[pq->len - 1];\n+\tpq->len--;\n+\n+\ti = 0;\n+\twhile (i < pq->len) {\n+\t\tint min = i;\n+\t\tint j = 2 * i + 1;\n+\t\tint k = 2 * i + 2;\n+\t\tif (j < pq->len && pq_less(pq->heap[j], pq->heap[i])) {\n+\t\t\tmin = j;\n+\t\t}\n+\t\tif (k < pq->len && pq_less(pq->heap[k], pq->heap[min])) {\n+\t\t\tmin = k;\n+\t\t}\n+\n+\t\tif (min == i) {\n+\t\t\tbreak;\n+\t\t}\n+\n+\t\tSWAP(pq->heap[i], pq->heap[min]);\n+\t\ti = min;\n+\t}\n+\n+\treturn e;\n+}\n+\n+void merged_iter_pqueue_add(struct merged_iter_pqueue *pq, struct pq_entry e)\n+{\n+\tint i = 0;\n+\tif (pq->len == pq->cap) {\n+\t\tpq->cap = 2 * pq->cap + 1;\n+\t\tpq->heap = reftable_realloc(pq->heap,\n+\t\t\t\t\t pq->cap * sizeof(struct pq_entry));\n+\t}\n+\n+\tpq->heap[pq->len++] = e;\n+\ti = pq->len - 1;\n+\twhile (i > 0) {\n+\t\tint j = (i - 1) / 2;\n+\t\tif (pq_less(pq->heap[j], pq->heap[i])) {\n+\t\t\tbreak;\n+\t\t}\n+\n+\t\tSWAP(pq->heap[j], pq->heap[i]);\n+\n+\t\ti = j;\n+\t}\n+}\n+\n+void merged_iter_pqueue_clear(struct merged_iter_pqueue *pq)\n+{\n+\tint i = 0;\n+\tfor (i = 0; i < pq->len; i++) {\n+\t\treftable_record_destroy(&pq->heap[i].rec);\n+\t}\n+\tFREE_AND_NULL(pq->heap);\n+\tpq->len = pq->cap = 0;\n+}\ndiff --git a/reftable/pq.h b/reftable/pq.h\nnew file mode 100644\nindex 0000000000..918ac3990d\n--- /dev/null\n+++ b/reftable/pq.h\n@@ -0,0 +1,34 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#ifndef PQ_H\n+#define PQ_H\n+\n+#include \"record.h\"\n+\n+struct pq_entry {\n+\tint index;\n+\tstruct reftable_record rec;\n+};\n+\n+int pq_less(struct pq_entry a, struct pq_entry b);\n+\n+struct merged_iter_pqueue {\n+\tstruct pq_entry *heap;\n+\tsize_t len;\n+\tsize_t cap;\n+};\n+\n+struct pq_entry merged_iter_pqueue_top(struct merged_iter_pqueue pq);\n+int merged_iter_pqueue_is_empty(struct merged_iter_pqueue pq);\n+void merged_iter_pqueue_check(struct merged_iter_pqueue pq);\n+struct pq_entry merged_iter_pqueue_remove(struct merged_iter_pqueue *pq);\n+void merged_iter_pqueue_add(struct merged_iter_pqueue *pq, struct pq_entry e);\n+void merged_iter_pqueue_clear(struct merged_iter_pqueue *pq);\n+\n+#endif\ndiff --git a/reftable/refname.c b/reftable/refname.c\nnew file mode 100644\nindex 0000000000..423e2b06bc\n--- /dev/null\n+++ b/reftable/refname.c\n@@ -0,0 +1,209 @@\n+/*\n+\n+ Use of this source code is governed by a BSD-style\n+ license that can be found in the LICENSE file or at\n+*/\n+\n+#include \"system.h\"\n+#include \"reftable.h\"\n+#include \"basics.h\"\n+#include \"refname.h\"\n+#include \"strbuf.h\"\n+\n+struct find_arg {\n+\tchar **names;\n+\tconst char *want;\n+};\n+\n+static int find_name(size_t k, void *arg)\n+{\n+\tstruct find_arg *f_arg = (struct find_arg *)arg;\n+\treturn strcmp(f_arg->names[k], f_arg->want) >= 0;\n+}\n+\n+int modification_has_ref(struct modification *mod, const char *name)\n+{\n+\tstruct reftable_ref_record ref = { 0 };\n+\tint err = 0;\n+\n+\tif (mod->add_len > 0) {\n+\t\tstruct find_arg arg = {\n+\t\t\t.want = name,\n+\t\t};\n+\t\tint idx = binsearch(mod->add_len, find_name, &arg);\n+\t\t\treturn 0;\n+\t\t}\n+\t}\n+\n+\tif (mod->del_len > 0) {\n+\t\tstruct find_arg arg = {\n+\t\t\t.names = mod->del,\n+\t\t\t.want = name,\n+\t\t};\n+\t\tint idx = binsearch(mod->del_len, find_name, &arg);\n+\t\tif (idx < mod->del_len && !strcmp(mod->del[idx], name)) {\n+\t\t\treturn 1;\n+\t\t}\n+\t}\n+\n+\terr = reftable_table_read_ref(&mod->tab, name, &ref);\n+\treftable_ref_record_clear(&ref);\n+\treturn err;\n+}\n+\n+static void modification_clear(struct modification *mod)\n+{\n+\t/* don't delete the strings themselves; they're owned by ref records.\n+\t */\n+\tFREE_AND_NULL(mod->del);\n+\tmod->del_len = 0;\n+}\n+\n+int modification_has_ref_with_prefix(struct modification *mod,\n+\t\t\t\t const char *prefix)\n+{\n+\tstruct reftable_iterator it = { NULL };\n+\tstruct reftable_ref_record ref = { NULL };\n+\tint err = 0;\n+\n+\tif (mod->add_len > 0) {\n+\t\tstruct find_arg arg = {\n+\t\t\t.want = prefix,\n+\t\t};\n+\t\tint idx = binsearch(mod->add_len, find_name, &arg);\n+\t\tif (idx < mod->add_len &&\n+\t\t\tgoto done;\n+\t}\n+\terr = reftable_table_seek_ref(&mod->tab, &it, prefix);\n+\tif (err)\n+\t\tgoto done;\n+\n+\twhile (1) {\n+\t\terr = reftable_iterator_next_ref(&it, &ref);\n+\t\tif (err)\n+\t\t\tgoto done;\n+\n+\t\tif (mod->del_len > 0) {\n+\t\t\tstruct find_arg arg = {\n+\t\t\t\t.names = mod->del,\n+\t\t\t\t.want = ref.refname,\n+\t\t\t};\n+\t\t\tint idx = binsearch(mod->del_len, find_name, &arg);\n+\t\t\tif (idx < mod->del_len &&\n+\t\t\t !strcmp(ref.refname, mod->del[idx])) {\n+\t\t\t\tcontinue;\n+\t\t\t}\n+\t\t}\n+\n+\t\tif (strncmp(ref.refname, prefix, strlen(prefix))) {\n+\t\t\terr = 1;\n+\t\t\tgoto done;\n+\t\t}\n+\t\terr = 0;\n+\t\tgoto done;\n+\t}\n+\n+done:\n+\treftable_ref_record_clear(&ref);\n+\treftable_iterator_destroy(&it);\n+\treturn err;\n+}\n+\n+int validate_refname(const char *name)\n+{\n+\twhile (1) {\n+\t\tchar *next = strchr(name, '/');\n+\t\tif (!*name) {\n+\t\t\treturn REFTABLE_REFNAME_ERROR;\n+\t\t}\n+\t\tif (!next) {\n+\t\t\treturn 0;\n+\t\t}\n+\t\tif (next - name == 0 || (next - name == 1 && *name == '.') ||\n+\t\t (next - name == 2 && name == '.' && name == '.'))\n+\t\t\treturn REFTABLE_REFNAME_ERROR;\n+\t\tname = next + 1;\n+\t}\n+\treturn 0;\n+}\n+\n+\t\t\t\t struct reftable_ref_record *recs, size_t sz)\n+{\n+\tstruct modification mod = {\n+\t\t.tab = tab,\n+\t\t.add = reftable_calloc(sizeof(char *) * sz),\n+\t\t.del = reftable_calloc(sizeof(char *) * sz),\n+\t};\n+\tint i = 0;\n+\tint err = 0;\n+\tfor (; i < sz; i++) {\n+\t\tif (reftable_ref_record_is_deletion(&recs[i])) {\n+\t\t\tmod.del[mod.del_len++] = recs[i].refname;\n+\t\t} else {\n+\t\t}\n+\t}\n+\n+\terr = modification_validate(&mod);\n+\tmodification_clear(&mod);\n+\treturn err;\n+}\n+\n+static void strbuf_trim_component(struct strbuf *sl)\n+{\n+\twhile (sl->len > 0) {\n+\t\tint is_slash = (sl->buf[sl->len - 1] == '/');\n+\t\tstrbuf_setlen(sl, sl->len - 1);\n+\t\tif (is_slash)\n+\t\t\tbreak;\n+\t}\n+}\n+\n+int modification_validate(struct modification *mod)\n+{\n+\tstruct strbuf slashed = STRBUF_INIT;\n+\tint err = 0;\n+\tint i = 0;\n+\tfor (; i < mod->add_len; i++) {\n+\t\tif (err)\n+\t\t\tgoto done;\n+\t\tstrbuf_reset(&slashed);\n+\n+\t\terr = modification_has_ref_with_prefix(mod, slashed.buf);\n+\t\tif (err == 0) {\n+\t\t\terr = REFTABLE_NAME_CONFLICT;\n+\t\t\tgoto done;\n+\t\t}\n+\t\tif (err < 0)\n+\t\t\tgoto done;\n+\n+\t\tstrbuf_reset(&slashed);\n+\t\twhile (slashed.len) {\n+\t\t\tstrbuf_trim_component(&slashed);\n+\t\t\terr = modification_has_ref(mod, slashed.buf);\n+\t\t\tif (err == 0) {\n+\t\t\t\terr = REFTABLE_NAME_CONFLICT;\n+\t\t\t\tgoto done;\n+\t\t\t}\n+\t\t\tif (err < 0)\n+\t\t\t\tgoto done;\n+\t\t}\n+\t}\n+\terr = 0;\n+done:\n+\tstrbuf_release(&slashed);\n+\treturn err;\n+}\ndiff --git a/reftable/refname.h b/reftable/refname.h\nnew file mode 100644\nindex 0000000000..13bf1e6861\n--- /dev/null\n+++ b/reftable/refname.h\n@@ -0,0 +1,38 @@\n+/*\n+\n+ Use of this source code is governed by a BSD-style\n+ license that can be found in the LICENSE file or at\n+*/\n+#ifndef REFNAME_H\n+#define REFNAME_H\n+\n+#include \"reftable.h\"\n+\n+struct modification {\n+\tstruct reftable_table tab;\n+\n+\n+\tchar **del;\n+\tsize_t del_len;\n+};\n+\n+int modification_has_ref(struct modification *mod, const char *name);\n+\n+int modification_has_ref_with_prefix(struct modification *mod,\n+\t\t\t\t const char *prefix);\n+\n+// 0 = OK.\n+int validate_refname(const char *name);\n+\n+\t\t\t\t struct reftable_ref_record *recs, size_t sz);\n+\n+int modification_validate(struct modification *mod);\n+\n+#endif\ndiff --git a/reftable/refname_test.c b/reftable/refname_test.c\nnew file mode 100644\n--- /dev/null\n+++ b/reftable/refname_test.c\n@@ -0,0 +1,100 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"reftable.h\"\n+\n+#include \"basics.h\"\n+#include \"block.h\"\n+#include \"blocksource.h\"\n+#include \"constants.h\"\n+#include \"record.h\"\n+#include \"refname.h\"\n+#include \"system.h\"\n+\n+#include \"test_framework.h\"\n+#include \"reftable-tests.h\"\n+\n+struct testcase {\n+\tchar *del;\n+\tint error_code;\n+};\n+\n+static void test_conflict(void)\n+{\n+\tstruct reftable_write_options opts = { 0 };\n+\tstruct strbuf buf = STRBUF_INIT;\n+\tstruct reftable_writer *w =\n+\tstruct reftable_ref_record rec = {\n+\t\t.refname = \"a/b\",\n+\t\t.target = \"destination\", /* make sure it's not a symref. */\n+\t\t.update_index = 1,\n+\t};\n+\tint err;\n+\tint i;\n+\tstruct reftable_block_source source = { 0 };\n+\tstruct reftable_reader *rd = NULL;\n+\tstruct reftable_table tab = { NULL };\n+\tstruct testcase cases[] = {\n+\t\t{ \"a/b/c\", NULL, REFTABLE_NAME_CONFLICT },\n+\t\t{ \"b\", NULL, 0 },\n+\t\t{ \"a\", NULL, REFTABLE_NAME_CONFLICT },\n+\t\t{ \"a\", \"a/b\", 0 },\n+\n+\t\t{ \"p/\", NULL, REFTABLE_REFNAME_ERROR },\n+\t\t{ \"p//q\", NULL, REFTABLE_REFNAME_ERROR },\n+\t\t{ \"p/./q\", NULL, REFTABLE_REFNAME_ERROR },\n+\t\t{ \"p/../q\", NULL, REFTABLE_REFNAME_ERROR },\n+\n+\t\t{ \"a/b/c\", \"a/b\", 0 },\n+\t\t{ NULL, \"a//b\", 0 },\n+\t};\n+\treftable_writer_set_limits(w, 1, 1);\n+\n+\tassert_err(err);\n+\n+\terr = reftable_writer_close(w);\n+\tassert_err(err);\n+\treftable_writer_free(w);\n+\n+\tblock_source_from_strbuf(&source, &buf);\n+\terr = reftable_new_reader(&rd, &source, \"filename\");\n+\tassert_err(err);\n+\n+\n+\tfor (i = 0; i < ARRAY_SIZE(cases); i++) {\n+\t\tstruct modification mod = {\n+\t\t\t.tab = tab,\n+\t\t};\n+\n+\t\tif (cases[i].add != NULL) {\n+\t\t}\n+\t\tif (cases[i].del != NULL) {\n+\t\t\tmod.del = &cases[i].del;\n+\t\t\tmod.del_len = 1;\n+\t\t}\n+\n+\t\terr = modification_validate(&mod);\n+\t\tassert(err == cases[i].error_code);\n+\t}\n+\n+\tstrbuf_release(&buf);\n+}\n+\n+int refname_test_main(int argc, const char *argv[])\n+{\n+\treturn test_main(argc, argv);\n+}\ndiff --git a/reftable/stack.c b/reftable/stack.c\nnew file mode 100644\nindex 0000000000..cf8a8e854b\n--- /dev/null\n+++ b/reftable/stack.c\n@@ -0,0 +1,1224 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"stack.h\"\n+\n+#include \"system.h\"\n+#include \"merged.h\"\n+#include \"refname.h\"\n+#include \"reftable.h\"\n+#include \"writer.h\"\n+\n+int reftable_new_stack(struct reftable_stack **dest, const char *dir,\n+\t\t struct reftable_write_options config)\n+{\n+\tstruct reftable_stack *p =\n+\t\treftable_calloc(sizeof(struct reftable_stack));\n+\tstruct strbuf list_file_name = STRBUF_INIT;\n+\tint err = 0;\n+\n+\tif (config.hash_id == 0) {\n+\t\tconfig.hash_id = SHA1_ID;\n+\t}\n+\n+\t*dest = NULL;\n+\n+\tstrbuf_reset(&list_file_name);\n+\n+\tp->list_file = strbuf_detach(&list_file_name, NULL);\n+\tp->reftable_dir = xstrdup(dir);\n+\tp->config = config;\n+\n+\tif (err < 0) {\n+\t\treftable_stack_destroy(p);\n+\t} else {\n+\t\t*dest = p;\n+\t}\n+\treturn err;\n+}\n+\n+static int fd_read_lines(int fd, char ***namesp)\n+{\n+\toff_t size = lseek(fd, 0, SEEK_END);\n+\tchar *buf = NULL;\n+\tint err = 0;\n+\tif (size < 0) {\n+\t\terr = REFTABLE_IO_ERROR;\n+\t\tgoto done;\n+\t}\n+\terr = lseek(fd, 0, SEEK_SET);\n+\tif (err < 0) {\n+\t\terr = REFTABLE_IO_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+\tbuf = reftable_malloc(size + 1);\n+\tif (read(fd, buf, size) != size) {\n+\t\terr = REFTABLE_IO_ERROR;\n+\t\tgoto done;\n+\t}\n+\tbuf[size] = 0;\n+\n+\tparse_names(buf, size, namesp);\n+\n+done:\n+\treftable_free(buf);\n+\treturn err;\n+}\n+\n+int read_lines(const char *filename, char ***namesp)\n+{\n+\tint fd = open(filename, O_RDONLY, 0644);\n+\tint err = 0;\n+\tif (fd < 0) {\n+\t\tif (errno == ENOENT) {\n+\t\t\t*namesp = reftable_calloc(sizeof(char *));\n+\t\t\treturn 0;\n+\t\t}\n+\n+\t\treturn REFTABLE_IO_ERROR;\n+\t}\n+\tclose(fd);\n+\treturn err;\n+}\n+\n+struct reftable_merged_table *\n+reftable_stack_merged_table(struct reftable_stack *st)\n+{\n+\treturn st->merged;\n+}\n+\n+/* Close and free the stack */\n+void reftable_stack_destroy(struct reftable_stack *st)\n+{\n+\tif (st->merged != NULL) {\n+\t\treftable_merged_table_free(st->merged);\n+\t\tst->merged = NULL;\n+\t}\n+\n+\tif (st->readers != NULL) {\n+\t\tint i = 0;\n+\t\tfor (i = 0; i < st->readers_len; i++) {\n+\t\t}\n+\t}\n+\tFREE_AND_NULL(st->list_file);\n+\tFREE_AND_NULL(st->reftable_dir);\n+\treftable_free(st);\n+}\n+\n+\t\t\t\t\t\t int cur_len)\n+{\n+\t\treftable_calloc(sizeof(struct reftable_reader *) * cur_len);\n+\tint i = 0;\n+\tfor (i = 0; i < cur_len; i++) {\n+\t}\n+\treturn cur;\n+}\n+\n+static int reftable_stack_reload_once(struct reftable_stack *st, char **names,\n+\t\t\t\t int reuse_open)\n+{\n+\tint cur_len = st->merged == NULL ? 0 : st->merged->stack_len;\n+\tint err = 0;\n+\tint names_len = names_length(names);\n+\t\treftable_calloc(sizeof(struct reftable_reader *) * names_len);\n+\tstruct reftable_table *new_tables =\n+\t\treftable_calloc(sizeof(struct reftable_table) * names_len);\n+\tstruct reftable_merged_table *new_merged = NULL;\n+\tint i;\n+\n+\twhile (*names) {\n+\t\tstruct reftable_reader *rd = NULL;\n+\t\tchar *name = *names++;\n+\n+\t\t/* this is linear; we assume compaction keeps the number of\n+\t\t tables under control so this is not quadratic. */\n+\t\tint j = 0;\n+\t\tfor (j = 0; reuse_open && j < cur_len; j++) {\n+\t\t\tif (cur[j] != NULL && 0 == strcmp(cur[j]->name, name)) {\n+\t\t\t\trd = cur[j];\n+\t\t\t\tcur[j] = NULL;\n+\t\t\t\tbreak;\n+\t\t\t}\n+\t\t}\n+\n+\t\tif (rd == NULL) {\n+\t\t\tstruct reftable_block_source src = { 0 };\n+\t\t\tstruct strbuf table_path = STRBUF_INIT;\n+\n+\t\t\terr = reftable_block_source_from_file(&src,\n+\t\t\t\t\t\t\t table_path.buf);\n+\t\t\tstrbuf_release(&table_path);\n+\n+\t\t\tif (err < 0)\n+\t\t\t\tgoto done;\n+\n+\t\t\terr = reftable_new_reader(&rd, &src, name);\n+\t\t\tif (err < 0)\n+\t\t\t\tgoto done;\n+\t\t}\n+\n+\t}\n+\n+\t/* success! */\n+\terr = reftable_new_merged_table(&new_merged, new_tables,\n+\tif (err < 0)\n+\t\tgoto done;\n+\n+\tnew_tables = NULL;\n+\tif (st->merged != NULL) {\n+\t\tmerged_table_clear(st->merged);\n+\t\treftable_merged_table_free(st->merged);\n+\t}\n+\tif (st->readers != NULL) {\n+\t}\n+\n+\tnew_merged->suppress_deletions = 1;\n+\tst->merged = new_merged;\n+\tfor (i = 0; i < cur_len; i++) {\n+\t\tif (cur[i] != NULL) {\n+\t\t}\n+\t}\n+\n+done:\n+\tfor (i = 0; i < new_readers_len; i++) {\n+\t}\n+\treftable_free(new_tables);\n+\treftable_free(cur);\n+\treturn err;\n+}\n+\n+/* return negative if a before b. */\n+static int tv_cmp(struct timeval *a, struct timeval *b)\n+{\n+\ttime_t diff = a->tv_sec - b->tv_sec;\n+\tint udiff = a->tv_usec - b->tv_usec;\n+\n+\tif (diff != 0)\n+\t\treturn diff;\n+\n+\treturn udiff;\n+}\n+\n+int reftable_stack_reload_maybe_reuse(struct reftable_stack *st, int reuse_open)\n+{\n+\tstruct timeval deadline = { 0 };\n+\tint err = gettimeofday(&deadline, NULL);\n+\tint64_t delay = 0;\n+\tint tries = 0;\n+\tif (err < 0)\n+\t\treturn err;\n+\n+\twhile (1) {\n+\t\tchar **names = NULL;\n+\t\tchar **names_after = NULL;\n+\t\tstruct timeval now = { 0 };\n+\t\tint err = gettimeofday(&now, NULL);\n+\t\tint err2 = 0;\n+\t\tif (err < 0) {\n+\t\t\treturn err;\n+\t\t}\n+\n+\t\t/* Only look at deadlines after the first few times. This\n+\t\t simplifies debugging in GDB */\n+\t\ttries++;\n+\t\tif (tries > 3 && tv_cmp(&now, &deadline) >= 0) {\n+\t\t\tbreak;\n+\t\t}\n+\n+\t\tif (err < 0) {\n+\t\t\tfree_names(names);\n+\t\t\treturn err;\n+\t\t}\n+\t\terr = reftable_stack_reload_once(st, names, reuse_open);\n+\t\tif (err == 0) {\n+\t\t\tfree_names(names);\n+\t\t\tbreak;\n+\t\t}\n+\t\tif (err != REFTABLE_NOT_EXIST_ERROR) {\n+\t\t\tfree_names(names);\n+\t\t\treturn err;\n+\t\t}\n+\n+\t\t/* err == REFTABLE_NOT_EXIST_ERROR can be caused by a concurrent\n+\t\t writer. Check if there was one by checking if the name list\n+\t\t changed.\n+\t\t*/\n+\t\tif (err2 < 0) {\n+\t\t\tfree_names(names);\n+\t\t\treturn err2;\n+\t\t}\n+\n+\t\tif (names_equal(names_after, names)) {\n+\t\t\tfree_names(names);\n+\t\t\tfree_names(names_after);\n+\t\t\treturn err;\n+\t\t}\n+\t\tfree_names(names);\n+\t\tfree_names(names_after);\n+\n+\t\tdelay = delay + (delay * rand()) / RAND_MAX + 1;\n+\t\tsleep_millisec(delay);\n+\t}\n+\n+\treturn 0;\n+}\n+\n+/* -1 = error\n+ 0 = up to date\n+ 1 = changed. */\n+static int stack_uptodate(struct reftable_stack *st)\n+{\n+\tchar **names = NULL;\n+\tint err = read_lines(st->list_file, &names);\n+\tint i = 0;\n+\tif (err < 0)\n+\t\treturn err;\n+\n+\tfor (i = 0; i < st->readers_len; i++) {\n+\t\tif (names[i] == NULL) {\n+\t\t\terr = 1;\n+\t\t\tgoto done;\n+\t\t}\n+\n+\t\t\terr = 1;\n+\t\t\tgoto done;\n+\t\t}\n+\t}\n+\n+\tif (names[st->merged->stack_len] != NULL) {\n+\t\terr = 1;\n+\t\tgoto done;\n+\t}\n+\n+done:\n+\tfree_names(names);\n+\treturn err;\n+}\n+\n+{\n+\tint err = stack_uptodate(st);\n+\tif (err > 0)\n+\treturn err;\n+}\n+\n+\t\t int (*write)(struct reftable_writer *wr, void *arg),\n+\t\t void *arg)\n+{\n+\tint err = stack_try_add(st, write, arg);\n+\tif (err < 0) {\n+\t\tif (err == REFTABLE_LOCK_ERROR) {\n+\t\t\t/* Ignore error return, we want to propagate\n+\t\t\t REFTABLE_LOCK_ERROR.\n+\t\t\t*/\n+\t\t}\n+\t\treturn err;\n+\t}\n+\n+\tif (!st->disable_auto_compact)\n+\t\treturn reftable_stack_auto_compact(st);\n+\n+\treturn 0;\n+}\n+\n+static void format_name(struct strbuf *dest, uint64_t min, uint64_t max)\n+{\n+\tchar buf;\n+\tsnprintf(buf, sizeof(buf), \"0x%012\" PRIx64 \"-0x%012\" PRIx64, min, max);\n+\tstrbuf_reset(dest);\n+}\n+\n+\tint lock_file_fd;\n+\tstruct strbuf lock_file_name;\n+\tstruct reftable_stack *stack;\n+\tchar **names;\n+\tchar **new_tables;\n+\tint new_tables_len;\n+\tuint64_t next_update_index;\n+};\n+\n+\t{ \\\n+\t\t.lock_file_name = STRBUF_INIT \\\n+\t}\n+\n+\t\t\t\t\tstruct reftable_stack *st)\n+{\n+\tint err = 0;\n+\n+\n+\t\t\t\t O_EXCL | O_CREAT | O_WRONLY, 0644);\n+\tif (add->lock_file_fd < 0) {\n+\t\tif (errno == EEXIST) {\n+\t\t\terr = REFTABLE_LOCK_ERROR;\n+\t\t} else {\n+\t\t\terr = REFTABLE_IO_ERROR;\n+\t\t}\n+\t\tgoto done;\n+\t}\n+\terr = stack_uptodate(st);\n+\tif (err < 0)\n+\t\tgoto done;\n+\n+\tif (err > 1) {\n+\t\terr = REFTABLE_LOCK_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+done:\n+\tif (err) {\n+\t}\n+\treturn err;\n+}\n+\n+{\n+\tint i = 0;\n+\tstruct strbuf nm = STRBUF_INIT;\n+\tfor (i = 0; i < add->new_tables_len; i++) {\n+\t\tstrbuf_reset(&nm);\n+\t}\n+\n+\tif (add->lock_file_fd > 0) {\n+\t}\n+\tif (add->lock_file_name.len > 0) {\n+\t}\n+\n+\tstrbuf_release(&nm);\n+}\n+\n+{\n+\tif (add == NULL) {\n+\t\treturn;\n+\t}\n+}\n+\n+{\n+\tstruct strbuf table_list = STRBUF_INIT;\n+\tint i = 0;\n+\tint err = 0;\n+\t\tgoto done;\n+\n+\tfor (i = 0; i < add->stack->merged->stack_len; i++) {\n+\t}\n+\tfor (i = 0; i < add->new_tables_len; i++) {\n+\t}\n+\n+\terr = write(add->lock_file_fd, table_list.buf, table_list.len);\n+\tstrbuf_release(&table_list);\n+\tif (err < 0) {\n+\t\terr = REFTABLE_IO_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+\tif (err < 0) {\n+\t\terr = REFTABLE_IO_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+\tif (err < 0) {\n+\t\terr = REFTABLE_IO_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+\n+done:\n+\treturn err;\n+}\n+\n+\t\t\t\tstruct reftable_stack *st)\n+{\n+\tint err = 0;\n+\t*dest = reftable_calloc(sizeof(**dest));\n+\t**dest = empty;\n+\tif (err) {\n+\t\treftable_free(*dest);\n+\t\t*dest = NULL;\n+\t}\n+\treturn err;\n+}\n+\n+\t\t int (*write_table)(struct reftable_writer *wr, void *arg),\n+\t\t void *arg)\n+{\n+\tif (err < 0)\n+\t\tgoto done;\n+\tif (err > 0) {\n+\t\terr = REFTABLE_LOCK_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+\tif (err < 0)\n+\t\tgoto done;\n+\n+done:\n+\treturn err;\n+}\n+\n+\t\t\t int (*write_table)(struct reftable_writer *wr,\n+\t\t\t\t\t void *arg),\n+\t\t\t void *arg)\n+{\n+\tstruct strbuf temp_tab_file_name = STRBUF_INIT;\n+\tstruct strbuf tab_file_name = STRBUF_INIT;\n+\tstruct strbuf next_name = STRBUF_INIT;\n+\tstruct reftable_writer *wr = NULL;\n+\tint err = 0;\n+\tint tab_fd = 0;\n+\n+\tstrbuf_reset(&next_name);\n+\n+\n+\ttab_fd = mkstemp(temp_tab_file_name.buf);\n+\tif (tab_fd < 0) {\n+\t\terr = REFTABLE_IO_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+\twr = reftable_new_writer(reftable_fd_write, &tab_fd,\n+\terr = write_table(wr, arg);\n+\tif (err < 0)\n+\t\tgoto done;\n+\n+\terr = reftable_writer_close(wr);\n+\tif (err == REFTABLE_EMPTY_TABLE_ERROR) {\n+\t\terr = 0;\n+\t\tgoto done;\n+\t}\n+\tif (err < 0)\n+\t\tgoto done;\n+\n+\terr = close(tab_fd);\n+\ttab_fd = 0;\n+\tif (err < 0) {\n+\t\terr = REFTABLE_IO_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+\tif (err < 0)\n+\t\tgoto done;\n+\n+\tif (wr->min_update_index < add->next_update_index) {\n+\t\terr = REFTABLE_API_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+\tformat_name(&next_name, wr->min_update_index, wr->max_update_index);\n+\n+\n+\t/* TODO: should check destination out of paranoia */\n+\terr = rename(temp_tab_file_name.buf, tab_file_name.buf);\n+\tif (err < 0) {\n+\t\terr = REFTABLE_IO_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+done:\n+\tif (tab_fd > 0) {\n+\t\tclose(tab_fd);\n+\t\ttab_fd = 0;\n+\t}\n+\tif (temp_tab_file_name.len > 0) {\n+\t}\n+\n+\tstrbuf_release(&temp_tab_file_name);\n+\tstrbuf_release(&tab_file_name);\n+\tstrbuf_release(&next_name);\n+\treftable_writer_free(wr);\n+\treturn err;\n+}\n+\n+uint64_t reftable_stack_next_update_index(struct reftable_stack *st)\n+{\n+\tint sz = st->merged->stack_len;\n+\tif (sz > 0)\n+\t\t 1;\n+\treturn 1;\n+}\n+\n+static int stack_compact_locked(struct reftable_stack *st, int first, int last,\n+\t\t\t\tstruct strbuf *temp_tab,\n+\t\t\t\tstruct reftable_log_expiry_config *config)\n+{\n+\tstruct strbuf next_name = STRBUF_INIT;\n+\tint tab_fd = -1;\n+\tstruct reftable_writer *wr = NULL;\n+\tint err = 0;\n+\n+\tformat_name(&next_name,\n+\n+\tstrbuf_reset(temp_tab);\n+\n+\ttab_fd = mkstemp(temp_tab->buf);\n+\twr = reftable_new_writer(reftable_fd_write, &tab_fd, &st->config);\n+\n+\terr = stack_write_compact(st, wr, first, last, config);\n+\tif (err < 0)\n+\t\tgoto done;\n+\terr = reftable_writer_close(wr);\n+\tif (err < 0)\n+\t\tgoto done;\n+\n+\terr = close(tab_fd);\n+\ttab_fd = 0;\n+\n+done:\n+\treftable_writer_free(wr);\n+\tif (tab_fd > 0) {\n+\t\tclose(tab_fd);\n+\t\ttab_fd = 0;\n+\t}\n+\tif (err != 0 && temp_tab->len > 0) {\n+\t\tstrbuf_release(temp_tab);\n+\t}\n+\tstrbuf_release(&next_name);\n+\treturn err;\n+}\n+\n+int stack_write_compact(struct reftable_stack *st, struct reftable_writer *wr,\n+\t\t\tint first, int last,\n+\t\t\tstruct reftable_log_expiry_config *config)\n+{\n+\tint subtabs_len = last - first + 1;\n+\tstruct reftable_table *subtabs = reftable_calloc(\n+\t\tsizeof(struct reftable_table) * (last - first + 1));\n+\tstruct reftable_merged_table *mt = NULL;\n+\tint err = 0;\n+\tstruct reftable_iterator it = { 0 };\n+\tstruct reftable_ref_record ref = { 0 };\n+\tstruct reftable_log_record log = { 0 };\n+\n+\tuint64_t entries = 0;\n+\n+\tint i = 0, j = 0;\n+\tfor (i = first, j = 0; i <= last; i++) {\n+\t\tst->stats.bytes += t->size;\n+\t}\n+\n+\terr = reftable_new_merged_table(&mt, subtabs, subtabs_len,\n+\t\t\t\t\tst->config.hash_id);\n+\tif (err < 0) {\n+\t\treftable_free(subtabs);\n+\t\tgoto done;\n+\t}\n+\n+\terr = reftable_merged_table_seek_ref(mt, &it, \"\");\n+\tif (err < 0)\n+\t\tgoto done;\n+\n+\twhile (1) {\n+\t\terr = reftable_iterator_next_ref(&it, &ref);\n+\t\tif (err > 0) {\n+\t\t\terr = 0;\n+\t\t\tbreak;\n+\t\t}\n+\t\tif (err < 0) {\n+\t\t\tbreak;\n+\t\t}\n+\t\tif (first == 0 && reftable_ref_record_is_deletion(&ref)) {\n+\t\t\tcontinue;\n+\t\t}\n+\n+\t\tif (err < 0) {\n+\t\t\tbreak;\n+\t\t}\n+\t\tentries++;\n+\t}\n+\treftable_iterator_destroy(&it);\n+\n+\terr = reftable_merged_table_seek_log(mt, &it, \"\");\n+\tif (err < 0)\n+\t\tgoto done;\n+\n+\twhile (1) {\n+\t\terr = reftable_iterator_next_log(&it, &log);\n+\t\tif (err > 0) {\n+\t\t\terr = 0;\n+\t\t\tbreak;\n+\t\t}\n+\t\tif (err < 0) {\n+\t\t\tbreak;\n+\t\t}\n+\t\tif (first == 0 && reftable_log_record_is_deletion(&log)) {\n+\t\t\tcontinue;\n+\t\t}\n+\n+\t\tif (config != NULL && config->time > 0 &&\n+\t\t log.time < config->time) {\n+\t\t\tcontinue;\n+\t\t}\n+\n+\t\tif (config != NULL && config->min_update_index > 0 &&\n+\t\t log.update_index < config->min_update_index) {\n+\t\t\tcontinue;\n+\t\t}\n+\n+\t\tif (err < 0) {\n+\t\t\tbreak;\n+\t\t}\n+\t\tentries++;\n+\t}\n+\n+done:\n+\treftable_iterator_destroy(&it);\n+\tif (mt != NULL) {\n+\t\tmerged_table_clear(mt);\n+\t\treftable_merged_table_free(mt);\n+\t}\n+\treftable_ref_record_clear(&ref);\n+\treftable_log_record_clear(&log);\n+\tst->stats.entries_written += entries;\n+\treturn err;\n+}\n+\n+/* < 0: error. 0 == OK, > 0 attempt failed; could retry. */\n+static int stack_compact_range(struct reftable_stack *st, int first, int last,\n+\t\t\t struct reftable_log_expiry_config *expiry)\n+{\n+\tstruct strbuf temp_tab_file_name = STRBUF_INIT;\n+\tstruct strbuf new_table_name = STRBUF_INIT;\n+\tstruct strbuf lock_file_name = STRBUF_INIT;\n+\tstruct strbuf ref_list_contents = STRBUF_INIT;\n+\tstruct strbuf new_table_path = STRBUF_INIT;\n+\tint err = 0;\n+\tint have_lock = 0;\n+\tint lock_file_fd = 0;\n+\tint compact_count = last - first + 1;\n+\tchar **listp = NULL;\n+\tchar **delete_on_success =\n+\t\treftable_calloc(sizeof(char *) * (compact_count + 1));\n+\tchar **subtable_locks =\n+\t\treftable_calloc(sizeof(char *) * (compact_count + 1));\n+\tint i = 0;\n+\tint j = 0;\n+\tint is_empty_table = 0;\n+\n+\tif (first > last || (expiry == NULL && first == last)) {\n+\t\terr = 0;\n+\t\tgoto done;\n+\t}\n+\n+\tst->stats.attempts++;\n+\n+\tstrbuf_reset(&lock_file_name);\n+\n+\tlock_file_fd =\n+\t\topen(lock_file_name.buf, O_EXCL | O_CREAT | O_WRONLY, 0644);\n+\tif (lock_file_fd < 0) {\n+\t\tif (errno == EEXIST) {\n+\t\t\terr = 1;\n+\t\t} else {\n+\t\t\terr = REFTABLE_IO_ERROR;\n+\t\t}\n+\t\tgoto done;\n+\t}\n+\t/* Don't want to write to the lock for now. */\n+\tclose(lock_file_fd);\n+\tlock_file_fd = 0;\n+\n+\thave_lock = 1;\n+\terr = stack_uptodate(st);\n+\tif (err != 0)\n+\t\tgoto done;\n+\n+\tfor (i = first, j = 0; i <= last; i++) {\n+\t\tstruct strbuf subtab_file_name = STRBUF_INIT;\n+\t\tstruct strbuf subtab_lock = STRBUF_INIT;\n+\t\tint sublock_file_fd = -1;\n+\n+\n+\t\tstrbuf_reset(&subtab_lock);\n+\n+\t\tsublock_file_fd = open(subtab_lock.buf,\n+\t\t\t\t O_EXCL | O_CREAT | O_WRONLY, 0644);\n+\t\tif (sublock_file_fd > 0) {\n+\t\t\tclose(sublock_file_fd);\n+\t\t} else if (sublock_file_fd < 0) {\n+\t\t\tif (errno == EEXIST) {\n+\t\t\t\terr = 1;\n+\t\t\t} else {\n+\t\t\t\terr = REFTABLE_IO_ERROR;\n+\t\t\t}\n+\t\t}\n+\n+\t\tsubtable_locks[j] = subtab_lock.buf;\n+\t\tdelete_on_success[j] = subtab_file_name.buf;\n+\t\tj++;\n+\n+\t\tif (err != 0)\n+\t\t\tgoto done;\n+\t}\n+\n+\tif (err < 0)\n+\t\tgoto done;\n+\thave_lock = 0;\n+\n+\terr = stack_compact_locked(st, first, last, &temp_tab_file_name,\n+\t\t\t\t expiry);\n+\t/* Compaction + tombstones can create an empty table out of non-empty\n+\t * tables. */\n+\tis_empty_table = (err == REFTABLE_EMPTY_TABLE_ERROR);\n+\tif (is_empty_table) {\n+\t\terr = 0;\n+\t}\n+\tif (err < 0)\n+\t\tgoto done;\n+\n+\tlock_file_fd =\n+\t\topen(lock_file_name.buf, O_EXCL | O_CREAT | O_WRONLY, 0644);\n+\tif (lock_file_fd < 0) {\n+\t\tif (errno == EEXIST) {\n+\t\t\terr = 1;\n+\t\t} else {\n+\t\t\terr = REFTABLE_IO_ERROR;\n+\t\t}\n+\t\tgoto done;\n+\t}\n+\thave_lock = 1;\n+\n+\n+\tstrbuf_reset(&new_table_path);\n+\n+\tif (!is_empty_table) {\n+\t\terr = rename(temp_tab_file_name.buf, new_table_path.buf);\n+\t\tif (err < 0) {\n+\t\t\terr = REFTABLE_IO_ERROR;\n+\t\t\tgoto done;\n+\t\t}\n+\t}\n+\n+\tfor (i = 0; i < first; i++) {\n+\t}\n+\tif (!is_empty_table) {\n+\t}\n+\tfor (i = last + 1; i < st->merged->stack_len; i++) {\n+\t}\n+\n+\terr = write(lock_file_fd, ref_list_contents.buf, ref_list_contents.len);\n+\tif (err < 0) {\n+\t\terr = REFTABLE_IO_ERROR;\n+\t\tgoto done;\n+\t}\n+\terr = close(lock_file_fd);\n+\tlock_file_fd = 0;\n+\tif (err < 0) {\n+\t\terr = REFTABLE_IO_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+\terr = rename(lock_file_name.buf, st->list_file);\n+\tif (err < 0) {\n+\t\terr = REFTABLE_IO_ERROR;\n+\t\tgoto done;\n+\t}\n+\thave_lock = 0;\n+\n+\t/* Reload the stack before deleting. On windows, we can only delete the\n+\t files after we closed them.\n+\t*/\n+\terr = reftable_stack_reload_maybe_reuse(st, first < last);\n+\n+\tlistp = delete_on_success;\n+\twhile (*listp) {\n+\t\tif (strcmp(*listp, new_table_path.buf)) {\n+\t\t}\n+\t\tlistp++;\n+\t}\n+\n+done:\n+\tfree_names(delete_on_success);\n+\n+\tlistp = subtable_locks;\n+\twhile (*listp) {\n+\t\tlistp++;\n+\t}\n+\tfree_names(subtable_locks);\n+\tif (lock_file_fd > 0) {\n+\t\tclose(lock_file_fd);\n+\t\tlock_file_fd = 0;\n+\t}\n+\tif (have_lock) {\n+\t}\n+\tstrbuf_release(&new_table_name);\n+\tstrbuf_release(&new_table_path);\n+\tstrbuf_release(&ref_list_contents);\n+\tstrbuf_release(&temp_tab_file_name);\n+\tstrbuf_release(&lock_file_name);\n+\treturn err;\n+}\n+\n+int reftable_stack_compact_all(struct reftable_stack *st,\n+\t\t\t struct reftable_log_expiry_config *config)\n+{\n+\treturn stack_compact_range(st, 0, st->merged->stack_len - 1, config);\n+}\n+\n+static int stack_compact_range_stats(struct reftable_stack *st, int first,\n+\t\t\t\t int last,\n+\t\t\t\t struct reftable_log_expiry_config *config)\n+{\n+\tint err = stack_compact_range(st, first, last, config);\n+\tif (err > 0) {\n+\t\tst->stats.failures++;\n+\t}\n+\treturn err;\n+}\n+\n+static int segment_size(struct segment *s)\n+{\n+\treturn s->end - s->start;\n+}\n+\n+int fastlog2(uint64_t sz)\n+{\n+\tint l = 0;\n+\tif (sz == 0)\n+\t\treturn 0;\n+\tfor (; sz; sz /= 2) {\n+\t\tl++;\n+\t}\n+\treturn l - 1;\n+}\n+\n+struct segment *sizes_to_segments(int *seglen, uint64_t *sizes, int n)\n+{\n+\tstruct segment *segs = reftable_calloc(sizeof(struct segment) * n);\n+\tint next = 0;\n+\tstruct segment cur = { 0 };\n+\tint i = 0;\n+\n+\tif (n == 0) {\n+\t\t*seglen = 0;\n+\t\treturn segs;\n+\t}\n+\tfor (i = 0; i < n; i++) {\n+\t\tint log = fastlog2(sizes[i]);\n+\t\tif (cur.log != log && cur.bytes > 0) {\n+\t\t\tstruct segment fresh = {\n+\t\t\t\t.start = i,\n+\t\t\t};\n+\n+\t\t\tsegs[next++] = cur;\n+\t\t\tcur = fresh;\n+\t\t}\n+\n+\t\tcur.log = log;\n+\t\tcur.end = i + 1;\n+\t\tcur.bytes += sizes[i];\n+\t}\n+\tsegs[next++] = cur;\n+\t*seglen = next;\n+\treturn segs;\n+}\n+\n+struct segment suggest_compaction_segment(uint64_t *sizes, int n)\n+{\n+\tint seglen = 0;\n+\tstruct segment *segs = sizes_to_segments(&seglen, sizes, n);\n+\tstruct segment min_seg = {\n+\t\t.log = 64,\n+\t};\n+\tint i = 0;\n+\tfor (i = 0; i < seglen; i++) {\n+\t\tif (segment_size(&segs[i]) == 1) {\n+\t\t\tcontinue;\n+\t\t}\n+\n+\t\tif (segs[i].log < min_seg.log) {\n+\t\t\tmin_seg = segs[i];\n+\t\t}\n+\t}\n+\n+\twhile (min_seg.start > 0) {\n+\t\tint prev = min_seg.start - 1;\n+\t\tif (fastlog2(min_seg.bytes) < fastlog2(sizes[prev])) {\n+\t\t\tbreak;\n+\t\t}\n+\n+\t\tmin_seg.start = prev;\n+\t\tmin_seg.bytes += sizes[prev];\n+\t}\n+\n+\treftable_free(segs);\n+\treturn min_seg;\n+}\n+\n+static uint64_t *stack_table_sizes_for_compaction(struct reftable_stack *st)\n+{\n+\tuint64_t *sizes =\n+\t\treftable_calloc(sizeof(uint64_t) * st->merged->stack_len);\n+\tint version = (st->config.hash_id == SHA1_ID) ? 1 : 2;\n+\tint i = 0;\n+\tfor (i = 0; i < st->merged->stack_len; i++) {\n+\t}\n+\treturn sizes;\n+}\n+\n+int reftable_stack_auto_compact(struct reftable_stack *st)\n+{\n+\tuint64_t *sizes = stack_table_sizes_for_compaction(st);\n+\tstruct segment seg =\n+\t\tsuggest_compaction_segment(sizes, st->merged->stack_len);\n+\treftable_free(sizes);\n+\tif (segment_size(&seg) > 0)\n+\t\treturn stack_compact_range_stats(st, seg.start, seg.end - 1,\n+\t\t\t\t\t\t NULL);\n+\n+\treturn 0;\n+}\n+\n+struct reftable_compaction_stats *\n+reftable_stack_compaction_stats(struct reftable_stack *st)\n+{\n+\treturn &st->stats;\n+}\n+\n+int reftable_stack_read_ref(struct reftable_stack *st, const char *refname,\n+\t\t\t struct reftable_ref_record *ref)\n+{\n+\tstruct reftable_table tab = { NULL };\n+\treftable_table_from_merged_table(&tab, reftable_stack_merged_table(st));\n+}\n+\n+int reftable_stack_read_log(struct reftable_stack *st, const char *refname,\n+\t\t\t struct reftable_log_record *log)\n+{\n+\tstruct reftable_iterator it = { 0 };\n+\tstruct reftable_merged_table *mt = reftable_stack_merged_table(st);\n+\tint err = reftable_merged_table_seek_log(mt, &it, refname);\n+\tif (err)\n+\t\tgoto done;\n+\n+\terr = reftable_iterator_next_log(&it, log);\n+\tif (err)\n+\t\tgoto done;\n+\n+\tif (strcmp(log->refname, refname) ||\n+\t reftable_log_record_is_deletion(log)) {\n+\t\terr = 1;\n+\t\tgoto done;\n+\t}\n+\n+done:\n+\tif (err) {\n+\t\treftable_log_record_clear(log);\n+\t}\n+\treftable_iterator_destroy(&it);\n+\treturn err;\n+}\n+\n+int stack_check_addition(struct reftable_stack *st, const char *new_tab_name)\n+{\n+\tint err = 0;\n+\tstruct reftable_block_source src = { 0 };\n+\tstruct reftable_reader *rd = NULL;\n+\tstruct reftable_table tab = { NULL };\n+\tstruct reftable_ref_record *refs = NULL;\n+\tstruct reftable_iterator it = { NULL };\n+\tint cap = 0;\n+\tint len = 0;\n+\tint i = 0;\n+\n+\tif (st->config.skip_name_check)\n+\t\treturn 0;\n+\n+\terr = reftable_block_source_from_file(&src, new_tab_name);\n+\tif (err < 0)\n+\t\tgoto done;\n+\n+\terr = reftable_new_reader(&rd, &src, new_tab_name);\n+\tif (err < 0)\n+\t\tgoto done;\n+\n+\terr = reftable_reader_seek_ref(rd, &it, \"\");\n+\tif (err > 0) {\n+\t\terr = 0;\n+\t\tgoto done;\n+\t}\n+\tif (err < 0)\n+\t\tgoto done;\n+\n+\twhile (1) {\n+\t\tstruct reftable_ref_record ref = { 0 };\n+\t\terr = reftable_iterator_next_ref(&it, &ref);\n+\t\tif (err > 0) {\n+\t\t\tbreak;\n+\t\t}\n+\t\tif (err < 0)\n+\t\t\tgoto done;\n+\n+\t\tif (len >= cap) {\n+\t\t\tcap = 2 * cap + 1;\n+\t\t\trefs = reftable_realloc(refs, cap * sizeof(refs));\n+\t\t}\n+\n+\t\trefs[len++] = ref;\n+\t}\n+\n+\treftable_table_from_merged_table(&tab, reftable_stack_merged_table(st));\n+\n+\terr = validate_ref_record_addition(tab, refs, len);\n+\n+done:\n+\tfor (i = 0; i < len; i++) {\n+\t\treftable_ref_record_clear(&refs[i]);\n+\t}\n+\n+\tfree(refs);\n+\treftable_iterator_destroy(&it);\n+\treturn err;\n+}\ndiff --git a/reftable/stack.h b/reftable/stack.h\nnew file mode 100644\nindex 0000000000..5ef138b025\n--- /dev/null\n+++ b/reftable/stack.h\n@@ -0,0 +1,50 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#ifndef STACK_H\n+#define STACK_H\n+\n+#include \"reftable.h\"\n+#include \"system.h\"\n+\n+struct reftable_stack {\n+\tchar *list_file;\n+\tchar *reftable_dir;\n+\tint disable_auto_compact;\n+\n+\tstruct reftable_write_options config;\n+\n+\tstruct reftable_merged_table *merged;\n+\tstruct reftable_compaction_stats stats;\n+};\n+\n+int read_lines(const char *filename, char ***lines);\n+\t\t int (*write_table)(struct reftable_writer *wr, void *arg),\n+\t\t void *arg);\n+int stack_write_compact(struct reftable_stack *st, struct reftable_writer *wr,\n+\t\t\tint first, int last,\n+\t\t\tstruct reftable_log_expiry_config *config);\n+int fastlog2(uint64_t sz);\n+int stack_check_addition(struct reftable_stack *st, const char *new_tab_name);\n+\t\t\t\t int reuse_open);\n+\n+struct segment {\n+\tint start, end;\n+\tint log;\n+\tuint64_t bytes;\n+};\n+\n+struct segment *sizes_to_segments(int *seglen, uint64_t *sizes, int n);\n+struct segment suggest_compaction_segment(uint64_t *sizes, int n);\n+\n+#endif\ndiff --git a/reftable/stack_test.c b/reftable/stack_test.c\nnew file mode 100644\nindex 0000000000..de806441dc\n--- /dev/null\n+++ b/reftable/stack_test.c\n@@ -0,0 +1,787 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"stack.h\"\n+\n+#include \"system.h\"\n+\n+#include \"merged.h\"\n+#include \"basics.h\"\n+#include \"constants.h\"\n+#include \"record.h\"\n+#include \"reftable.h\"\n+#include \"test_framework.h\"\n+#include \"reftable-tests.h\"\n+\n+#include <sys/types.h>\n+#include <dirent.h>\n+\n+{\n+\tint fd = mkstemp(fn);\n+\tchar out = \"line1\\n\\nline2\\nline3\";\n+\tint n, err;\n+\tchar **names = NULL;\n+\tchar *want[] = { \"line1\", \"line2\", \"line3\" };\n+\tint i = 0;\n+\n+\tassert(fd > 0);\n+\tn = write(fd, out, strlen(out));\n+\tassert(n == strlen(out));\n+\terr = close(fd);\n+\tassert(err >= 0);\n+\n+\tassert_err(err);\n+\n+\tfor (i = 0; names[i] != NULL; i++) {\n+\t\tassert(0 == strcmp(want[i], names[i]));\n+\t}\n+\tfree_names(names);\n+\tremove(fn);\n+}\n+\n+static void test_parse_names(void)\n+{\n+\tchar buf[] = \"line\\n\";\n+\tchar **names = NULL;\n+\tparse_names(buf, strlen(buf), &names);\n+\n+\tassert(NULL != names);\n+\tassert(0 == strcmp(names, \"line\"));\n+\tassert(NULL == names);\n+\tfree_names(names);\n+}\n+\n+static void test_names_equal(void)\n+{\n+\tchar *a[] = { \"a\", \"b\", \"c\", NULL };\n+\tchar *b[] = { \"a\", \"b\", \"d\", NULL };\n+\tchar *c[] = { \"a\", \"b\", NULL };\n+\n+\tassert(names_equal(a, a));\n+\tassert(!names_equal(a, b));\n+\tassert(!names_equal(a, c));\n+}\n+\n+static int write_test_ref(struct reftable_writer *wr, void *arg)\n+{\n+\tstruct reftable_ref_record *ref = arg;\n+\treftable_writer_set_limits(wr, ref->update_index, ref->update_index);\n+}\n+\n+struct write_log_arg {\n+\tstruct reftable_log_record *log;\n+\tuint64_t update_index;\n+};\n+\n+static int write_test_log(struct reftable_writer *wr, void *arg)\n+{\n+\tstruct write_log_arg *wla = arg;\n+\n+\treftable_writer_set_limits(wr, wla->update_index, wla->update_index);\n+}\n+\n+{\n+\tchar dir = \"/tmp/stack_test.XXXXXX\";\n+\tstruct reftable_write_options cfg = { 0 };\n+\tstruct reftable_stack *st = NULL;\n+\tint err;\n+\tstruct reftable_ref_record ref = {\n+\t\t.update_index = 1,\n+\t\t.target = \"master\",\n+\t};\n+\tstruct reftable_ref_record dest = { 0 };\n+\n+\tassert(mkdtemp(dir));\n+\n+\terr = reftable_new_stack(&st, dir, cfg);\n+\tassert_err(err);\n+\n+\terr = reftable_stack_add(st, &write_test_ref, &ref);\n+\tassert_err(err);\n+\n+\terr = reftable_stack_read_ref(st, ref.refname, &dest);\n+\tassert_err(err);\n+\tassert(0 == strcmp(\"master\", dest.target));\n+\n+\treftable_ref_record_clear(&dest);\n+\treftable_stack_destroy(st);\n+\treftable_clear_dir(dir);\n+}\n+\n+static void test_reftable_stack_uptodate(void)\n+{\n+\tstruct reftable_write_options cfg = { 0 };\n+\tstruct reftable_stack *st1 = NULL;\n+\tstruct reftable_stack *st2 = NULL;\n+\tchar dir = \"/tmp/stack_test.XXXXXX\";\n+\tint err;\n+\tstruct reftable_ref_record ref1 = {\n+\t\t.update_index = 1,\n+\t\t.target = \"master\",\n+\t};\n+\tstruct reftable_ref_record ref2 = {\n+\t\t.refname = \"branch2\",\n+\t\t.update_index = 2,\n+\t\t.target = \"master\",\n+\t};\n+\n+\tassert(mkdtemp(dir));\n+\n+\terr = reftable_new_stack(&st1, dir, cfg);\n+\tassert_err(err);\n+\n+\terr = reftable_new_stack(&st2, dir, cfg);\n+\tassert_err(err);\n+\n+\terr = reftable_stack_add(st1, &write_test_ref, &ref1);\n+\tassert_err(err);\n+\n+\terr = reftable_stack_add(st2, &write_test_ref, &ref2);\n+\tassert(err == REFTABLE_LOCK_ERROR);\n+\n+\tassert_err(err);\n+\n+\terr = reftable_stack_add(st2, &write_test_ref, &ref2);\n+\tassert_err(err);\n+\treftable_stack_destroy(st1);\n+\treftable_stack_destroy(st2);\n+\treftable_clear_dir(dir);\n+}\n+\n+static void test_reftable_stack_transaction_api(void)\n+{\n+\tchar dir = \"/tmp/stack_test.XXXXXX\";\n+\tstruct reftable_write_options cfg = { 0 };\n+\tstruct reftable_stack *st = NULL;\n+\tint err;\n+\n+\tstruct reftable_ref_record ref = {\n+\t\t.update_index = 1,\n+\t\t.target = \"master\",\n+\t};\n+\tstruct reftable_ref_record dest = { 0 };\n+\n+\tassert(mkdtemp(dir));\n+\n+\terr = reftable_new_stack(&st, dir, cfg);\n+\tassert_err(err);\n+\n+\n+\tassert_err(err);\n+\n+\tassert_err(err);\n+\n+\tassert_err(err);\n+\n+\n+\terr = reftable_stack_read_ref(st, ref.refname, &dest);\n+\tassert_err(err);\n+\tassert(0 == strcmp(\"master\", dest.target));\n+\n+\treftable_ref_record_clear(&dest);\n+\treftable_stack_destroy(st);\n+\treftable_clear_dir(dir);\n+}\n+\n+static void test_reftable_stack_validate_refname(void)\n+{\n+\tstruct reftable_write_options cfg = { 0 };\n+\tstruct reftable_stack *st = NULL;\n+\tint err;\n+\tchar dir = \"/tmp/stack_test.XXXXXX\";\n+\tint i;\n+\tstruct reftable_ref_record ref = {\n+\t\t.refname = \"a/b\",\n+\t\t.update_index = 1,\n+\t\t.target = \"master\",\n+\t};\n+\tchar *additions[] = { \"a\", \"a/b/c\" };\n+\n+\tassert(mkdtemp(dir));\n+\terr = reftable_new_stack(&st, dir, cfg);\n+\tassert_err(err);\n+\n+\terr = reftable_stack_add(st, &write_test_ref, &ref);\n+\tassert_err(err);\n+\n+\tfor (i = 0; i < ARRAY_SIZE(additions); i++) {\n+\t\tstruct reftable_ref_record ref = {\n+\t\t\t.update_index = 1,\n+\t\t\t.target = \"master\",\n+\t\t};\n+\n+\t\terr = reftable_stack_add(st, &write_test_ref, &ref);\n+\t\tassert(err == REFTABLE_NAME_CONFLICT);\n+\t}\n+\n+\treftable_stack_destroy(st);\n+\treftable_clear_dir(dir);\n+}\n+\n+static int write_error(struct reftable_writer *wr, void *arg)\n+{\n+\treturn *((int *)arg);\n+}\n+\n+static void test_reftable_stack_update_index_check(void)\n+{\n+\tchar dir = \"/tmp/stack_test.XXXXXX\";\n+\tstruct reftable_write_options cfg = { 0 };\n+\tstruct reftable_stack *st = NULL;\n+\tint err;\n+\tstruct reftable_ref_record ref1 = {\n+\t\t.refname = \"name1\",\n+\t\t.update_index = 1,\n+\t\t.target = \"master\",\n+\t};\n+\tstruct reftable_ref_record ref2 = {\n+\t\t.refname = \"name2\",\n+\t\t.update_index = 1,\n+\t\t.target = \"master\",\n+\t};\n+\tassert(mkdtemp(dir));\n+\n+\terr = reftable_new_stack(&st, dir, cfg);\n+\tassert_err(err);\n+\n+\terr = reftable_stack_add(st, &write_test_ref, &ref1);\n+\tassert_err(err);\n+\n+\terr = reftable_stack_add(st, &write_test_ref, &ref2);\n+\tassert(err == REFTABLE_API_ERROR);\n+\treftable_stack_destroy(st);\n+\treftable_clear_dir(dir);\n+}\n+\n+static void test_reftable_stack_lock_failure(void)\n+{\n+\tchar dir = \"/tmp/stack_test.XXXXXX\";\n+\tstruct reftable_write_options cfg = { 0 };\n+\tstruct reftable_stack *st = NULL;\n+\tint err, i;\n+\tassert(mkdtemp(dir));\n+\n+\terr = reftable_new_stack(&st, dir, cfg);\n+\tassert_err(err);\n+\tfor (i = -1; i != REFTABLE_EMPTY_TABLE_ERROR; i--) {\n+\t\terr = reftable_stack_add(st, &write_error, &i);\n+\t\tassert(err == i);\n+\t}\n+\n+\treftable_stack_destroy(st);\n+\treftable_clear_dir(dir);\n+}\n+\n+{\n+\tint i = 0;\n+\tint err = 0;\n+\tstruct reftable_write_options cfg = {\n+\t\t.exact_log_message = 1,\n+\t};\n+\tstruct reftable_stack *st = NULL;\n+\tchar dir = \"/tmp/stack_test.XXXXXX\";\n+\tstruct reftable_ref_record refs = { { 0 } };\n+\tstruct reftable_log_record logs = { { 0 } };\n+\tint N = ARRAY_SIZE(refs);\n+\n+\tassert(mkdtemp(dir));\n+\n+\terr = reftable_new_stack(&st, dir, cfg);\n+\tassert_err(err);\n+\tst->disable_auto_compact = 1;\n+\n+\tfor (i = 0; i < N; i++) {\n+\t\tchar buf;\n+\t\tsnprintf(buf, sizeof(buf), \"branch%02d\", i);\n+\t\trefs[i].refname = xstrdup(buf);\n+\t\trefs[i].value = reftable_malloc(SHA1_SIZE);\n+\t\trefs[i].update_index = i + 1;\n+\t\tset_test_hash(refs[i].value, i);\n+\n+\t\tlogs[i].refname = xstrdup(buf);\n+\t\tlogs[i].update_index = N + i + 1;\n+\t\tlogs[i].new_hash = reftable_malloc(SHA1_SIZE);\n+\t\tlogs[i].email = xstrdup(\"identity@invalid\");\n+\t\tset_test_hash(logs[i].new_hash, i);\n+\t}\n+\n+\tfor (i = 0; i < N; i++) {\n+\t\tint err = reftable_stack_add(st, &write_test_ref, &refs[i]);\n+\t\tassert_err(err);\n+\t}\n+\n+\tfor (i = 0; i < N; i++) {\n+\t\tstruct write_log_arg arg = {\n+\t\t\t.log = &logs[i],\n+\t\t\t.update_index = reftable_stack_next_update_index(st),\n+\t\t};\n+\t\tint err = reftable_stack_add(st, &write_test_log, &arg);\n+\t\tassert_err(err);\n+\t}\n+\n+\terr = reftable_stack_compact_all(st, NULL);\n+\tassert_err(err);\n+\n+\tfor (i = 0; i < N; i++) {\n+\t\tstruct reftable_ref_record dest = { 0 };\n+\t\tint err = reftable_stack_read_ref(st, refs[i].refname, &dest);\n+\t\tassert_err(err);\n+\t\tassert(reftable_ref_record_equal(&dest, refs + i, SHA1_SIZE));\n+\t\treftable_ref_record_clear(&dest);\n+\t}\n+\n+\tfor (i = 0; i < N; i++) {\n+\t\tstruct reftable_log_record dest = { 0 };\n+\t\tint err = reftable_stack_read_log(st, refs[i].refname, &dest);\n+\t\tassert_err(err);\n+\t\tassert(reftable_log_record_equal(&dest, logs + i, SHA1_SIZE));\n+\t\treftable_log_record_clear(&dest);\n+\t}\n+\n+\t/* cleanup */\n+\treftable_stack_destroy(st);\n+\tfor (i = 0; i < N; i++) {\n+\t\treftable_ref_record_clear(&refs[i]);\n+\t\treftable_log_record_clear(&logs[i]);\n+\t}\n+\treftable_clear_dir(dir);\n+}\n+\n+static void test_reftable_stack_log_normalize(void)\n+{\n+\tint err = 0;\n+\tstruct reftable_write_options cfg = {\n+\t\t0,\n+\t};\n+\tstruct reftable_stack *st = NULL;\n+\tchar dir = \"/tmp/stack_test.XXXXXX\";\n+\n+\tuint8_t h1[SHA1_SIZE] = { 0x01 }, h2[SHA1_SIZE] = { 0x02 };\n+\n+\tstruct reftable_log_record input = {\n+\t\t.refname = \"branch\",\n+\t\t.update_index = 1,\n+\t\t.new_hash = h1,\n+\t\t.old_hash = h2,\n+\t};\n+\tstruct reftable_log_record dest = {\n+\t\t.update_index = 0,\n+\t};\n+\tstruct write_log_arg arg = {\n+\t\t.log = &input,\n+\t\t.update_index = 1,\n+\t};\n+\n+\tassert(mkdtemp(dir));\n+\terr = reftable_new_stack(&st, dir, cfg);\n+\tassert_err(err);\n+\n+\tinput.message = \"one\\ntwo\";\n+\terr = reftable_stack_add(st, &write_test_log, &arg);\n+\tassert(err == REFTABLE_API_ERROR);\n+\n+\tinput.message = \"one\";\n+\terr = reftable_stack_add(st, &write_test_log, &arg);\n+\tassert_err(err);\n+\n+\terr = reftable_stack_read_log(st, input.refname, &dest);\n+\tassert_err(err);\n+\tassert(0 == strcmp(dest.message, \"one\\n\"));\n+\n+\tinput.message = \"two\\n\";\n+\targ.update_index = 2;\n+\terr = reftable_stack_add(st, &write_test_log, &arg);\n+\tassert_err(err);\n+\terr = reftable_stack_read_log(st, input.refname, &dest);\n+\tassert_err(err);\n+\tassert(0 == strcmp(dest.message, \"two\\n\"));\n+\n+\t/* cleanup */\n+\treftable_stack_destroy(st);\n+\treftable_log_record_clear(&dest);\n+\treftable_clear_dir(dir);\n+}\n+\n+static void test_reftable_stack_tombstone(void)\n+{\n+\tint i = 0;\n+\tchar dir = \"/tmp/stack_test.XXXXXX\";\n+\tstruct reftable_write_options cfg = { 0 };\n+\tstruct reftable_stack *st = NULL;\n+\tint err;\n+\tstruct reftable_ref_record refs = { { 0 } };\n+\tstruct reftable_log_record logs = { { 0 } };\n+\tint N = ARRAY_SIZE(refs);\n+\tstruct reftable_ref_record dest = { 0 };\n+\tstruct reftable_log_record log_dest = { 0 };\n+\n+\tassert(mkdtemp(dir));\n+\n+\terr = reftable_new_stack(&st, dir, cfg);\n+\tassert_err(err);\n+\n+\tfor (i = 0; i < N; i++) {\n+\t\tconst char *buf = \"branch\";\n+\t\trefs[i].refname = xstrdup(buf);\n+\t\trefs[i].update_index = i + 1;\n+\t\tif (i % 2 == 0) {\n+\t\t\trefs[i].value = reftable_malloc(SHA1_SIZE);\n+\t\t\tset_test_hash(refs[i].value, i);\n+\t\t}\n+\t\tlogs[i].refname = xstrdup(buf);\n+\t\t/* update_index is part of the key. */\n+\t\tlogs[i].update_index = 42;\n+\t\tif (i % 2 == 0) {\n+\t\t\tlogs[i].new_hash = reftable_malloc(SHA1_SIZE);\n+\t\t\tset_test_hash(logs[i].new_hash, i);\n+\t\t\tlogs[i].email = xstrdup(\"identity@invalid\");\n+\t\t}\n+\t}\n+\tfor (i = 0; i < N; i++) {\n+\t\tint err = reftable_stack_add(st, &write_test_ref, &refs[i]);\n+\t\tassert_err(err);\n+\t}\n+\tfor (i = 0; i < N; i++) {\n+\t\tstruct write_log_arg arg = {\n+\t\t\t.log = &logs[i],\n+\t\t\t.update_index = reftable_stack_next_update_index(st),\n+\t\t};\n+\t\tint err = reftable_stack_add(st, &write_test_log, &arg);\n+\t\tassert_err(err);\n+\t}\n+\n+\terr = reftable_stack_read_ref(st, \"branch\", &dest);\n+\tassert(err == 1);\n+\treftable_ref_record_clear(&dest);\n+\n+\terr = reftable_stack_read_log(st, \"branch\", &log_dest);\n+\tassert(err == 1);\n+\treftable_log_record_clear(&log_dest);\n+\n+\terr = reftable_stack_compact_all(st, NULL);\n+\tassert_err(err);\n+\n+\terr = reftable_stack_read_ref(st, \"branch\", &dest);\n+\tassert(err == 1);\n+\n+\terr = reftable_stack_read_log(st, \"branch\", &log_dest);\n+\tassert(err == 1);\n+\treftable_ref_record_clear(&dest);\n+\treftable_log_record_clear(&log_dest);\n+\n+\t/* cleanup */\n+\treftable_stack_destroy(st);\n+\tfor (i = 0; i < N; i++) {\n+\t\treftable_ref_record_clear(&refs[i]);\n+\t\treftable_log_record_clear(&logs[i]);\n+\t}\n+\treftable_clear_dir(dir);\n+}\n+\n+static void test_reftable_stack_hash_id(void)\n+{\n+\tchar dir = \"/tmp/stack_test.XXXXXX\";\n+\tstruct reftable_write_options cfg = { 0 };\n+\tstruct reftable_stack *st = NULL;\n+\tint err;\n+\n+\tstruct reftable_ref_record ref = {\n+\t\t.refname = \"master\",\n+\t\t.target = \"target\",\n+\t\t.update_index = 1,\n+\t};\n+\tstruct reftable_write_options cfg32 = { .hash_id = SHA256_ID };\n+\tstruct reftable_stack *st32 = NULL;\n+\tstruct reftable_write_options cfg_default = { 0 };\n+\tstruct reftable_stack *st_default = NULL;\n+\tstruct reftable_ref_record dest = { 0 };\n+\n+\tassert(mkdtemp(dir));\n+\terr = reftable_new_stack(&st, dir, cfg);\n+\tassert_err(err);\n+\n+\terr = reftable_stack_add(st, &write_test_ref, &ref);\n+\tassert_err(err);\n+\n+\t/* can't read it with the wrong hash ID. */\n+\terr = reftable_new_stack(&st32, dir, cfg32);\n+\tassert(err == REFTABLE_FORMAT_ERROR);\n+\n+\t/* check that we can read it back with default config too. */\n+\terr = reftable_new_stack(&st_default, dir, cfg_default);\n+\tassert_err(err);\n+\n+\terr = reftable_stack_read_ref(st_default, \"master\", &dest);\n+\tassert_err(err);\n+\n+\tassert(!strcmp(dest.target, ref.target));\n+\treftable_ref_record_clear(&dest);\n+\treftable_stack_destroy(st);\n+\treftable_stack_destroy(st_default);\n+\treftable_clear_dir(dir);\n+}\n+\n+static void test_log2(void)\n+{\n+\tassert(1 == fastlog2(3));\n+\tassert(2 == fastlog2(4));\n+\tassert(2 == fastlog2(5));\n+}\n+\n+static void test_sizes_to_segments(void)\n+{\n+\tuint64_t sizes[] = { 2, 3, 4, 5, 7, 9 };\n+\t/* .................0 1 2 3 4 5 */\n+\n+\tint seglen = 0;\n+\tstruct segment *segs =\n+\t\tsizes_to_segments(&seglen, sizes, ARRAY_SIZE(sizes));\n+\tassert(segs.log == 3);\n+\tassert(segs.start == 5);\n+\tassert(segs.end == 6);\n+\n+\tassert(segs.log == 2);\n+\tassert(segs.start == 2);\n+\tassert(segs.end == 5);\n+\treftable_free(segs);\n+}\n+\n+static void test_sizes_to_segments_empty(void)\n+{\n+\tuint64_t sizes;\n+\n+\tint seglen = 0;\n+\tstruct segment *segs =\n+\t\tsizes_to_segments(&seglen, sizes, ARRAY_SIZE(sizes));\n+\tassert(seglen == 0);\n+\treftable_free(segs);\n+}\n+\n+static void test_sizes_to_segments_all_equal(void)\n+{\n+\tuint64_t sizes[] = { 5, 5 };\n+\n+\tint seglen = 0;\n+\tstruct segment *segs =\n+\t\tsizes_to_segments(&seglen, sizes, ARRAY_SIZE(sizes));\n+\tassert(seglen == 1);\n+\tassert(segs.start == 0);\n+\tassert(segs.end == 2);\n+\treftable_free(segs);\n+}\n+\n+static void test_suggest_compaction_segment(void)\n+{\n+\tuint64_t sizes[] = { 128, 64, 17, 16, 9, 9, 9, 16, 16 };\n+\t/* .................0 1 2 3 4 5 6 */\n+\tstruct segment min =\n+\t\tsuggest_compaction_segment(sizes, ARRAY_SIZE(sizes));\n+\tassert(min.start == 2);\n+\tassert(min.end == 7);\n+}\n+\n+static void test_suggest_compaction_segment_nothing(void)\n+{\n+\tuint64_t sizes[] = { 64, 32, 16, 8, 4, 2 };\n+\tstruct segment result =\n+\t\tsuggest_compaction_segment(sizes, ARRAY_SIZE(sizes));\n+\tassert(result.start == result.end);\n+}\n+\n+static void test_reflog_expire(void)\n+{\n+\tchar dir = \"/tmp/stack.test_reflog_expire.XXXXXX\";\n+\tstruct reftable_write_options cfg = { 0 };\n+\tstruct reftable_stack *st = NULL;\n+\tstruct reftable_log_record logs = { { 0 } };\n+\tint N = ARRAY_SIZE(logs) - 1;\n+\tint i = 0;\n+\tint err;\n+\tstruct reftable_log_expiry_config expiry = {\n+\t\t.time = 10,\n+\t};\n+\tstruct reftable_log_record log = { 0 };\n+\n+\tassert(mkdtemp(dir));\n+\n+\terr = reftable_new_stack(&st, dir, cfg);\n+\tassert_err(err);\n+\n+\tfor (i = 1; i <= N; i++) {\n+\t\tchar buf;\n+\t\tsnprintf(buf, sizeof(buf), \"branch%02d\", i);\n+\n+\t\tlogs[i].refname = xstrdup(buf);\n+\t\tlogs[i].update_index = i;\n+\t\tlogs[i].time = i;\n+\t\tlogs[i].new_hash = reftable_malloc(SHA1_SIZE);\n+\t\tlogs[i].email = xstrdup(\"identity@invalid\");\n+\t\tset_test_hash(logs[i].new_hash, i);\n+\t}\n+\n+\tfor (i = 1; i <= N; i++) {\n+\t\tstruct write_log_arg arg = {\n+\t\t\t.log = &logs[i],\n+\t\t\t.update_index = reftable_stack_next_update_index(st),\n+\t\t};\n+\t\tint err = reftable_stack_add(st, &write_test_log, &arg);\n+\t\tassert_err(err);\n+\t}\n+\n+\terr = reftable_stack_compact_all(st, NULL);\n+\tassert_err(err);\n+\n+\terr = reftable_stack_compact_all(st, &expiry);\n+\tassert_err(err);\n+\n+\terr = reftable_stack_read_log(st, logs.refname, &log);\n+\tassert(err == 1);\n+\n+\terr = reftable_stack_read_log(st, logs.refname, &log);\n+\tassert_err(err);\n+\n+\texpiry.min_update_index = 15;\n+\terr = reftable_stack_compact_all(st, &expiry);\n+\tassert_err(err);\n+\n+\terr = reftable_stack_read_log(st, logs.refname, &log);\n+\tassert(err == 1);\n+\n+\terr = reftable_stack_read_log(st, logs.refname, &log);\n+\tassert_err(err);\n+\n+\t/* cleanup */\n+\treftable_stack_destroy(st);\n+\tfor (i = 0; i <= N; i++) {\n+\t\treftable_log_record_clear(&logs[i]);\n+\t}\n+\treftable_clear_dir(dir);\n+\treftable_log_record_clear(&log);\n+}\n+\n+static int write_nothing(struct reftable_writer *wr, void *arg)\n+{\n+\treftable_writer_set_limits(wr, 1, 1);\n+\treturn 0;\n+}\n+\n+{\n+\tstruct reftable_write_options cfg = { 0 };\n+\tstruct reftable_stack *st = NULL;\n+\tint err;\n+\tchar dir = \"/tmp/stack_test.XXXXXX\";\n+\tstruct reftable_stack *st2 = NULL;\n+\n+\tassert(mkdtemp(dir));\n+\n+\terr = reftable_new_stack(&st, dir, cfg);\n+\tassert_err(err);\n+\n+\terr = reftable_stack_add(st, &write_nothing, NULL);\n+\tassert_err(err);\n+\n+\terr = reftable_new_stack(&st2, dir, cfg);\n+\tassert_err(err);\n+\treftable_clear_dir(dir);\n+\treftable_stack_destroy(st);\n+\treftable_stack_destroy(st2);\n+}\n+\n+static void test_reftable_stack_auto_compaction(void)\n+{\n+\tstruct reftable_write_options cfg = { 0 };\n+\tstruct reftable_stack *st = NULL;\n+\tchar dir = \"/tmp/stack_test.XXXXXX\";\n+\tint err, i;\n+\tint N = 100;\n+\tassert(mkdtemp(dir));\n+\n+\terr = reftable_new_stack(&st, dir, cfg);\n+\tassert_err(err);\n+\n+\tfor (i = 0; i < N; i++) {\n+\t\tchar name;\n+\t\tstruct reftable_ref_record ref = {\n+\t\t\t.refname = name,\n+\t\t\t.update_index = reftable_stack_next_update_index(st),\n+\t\t\t.target = \"master\",\n+\t\t};\n+\t\tsnprintf(name, sizeof(name), \"branch%04d\", i);\n+\n+\t\terr = reftable_stack_add(st, &write_test_ref, &ref);\n+\t\tassert_err(err);\n+\n+\t\tassert(i < 3 || st->merged->stack_len < 2 * fastlog2(i));\n+\t}\n+\n+\tassert(reftable_stack_compaction_stats(st)->entries_written <\n+\t (uint64_t)(N * fastlog2(N)));\n+\n+\treftable_stack_destroy(st);\n+\treftable_clear_dir(dir);\n+}\n+\n+int stack_test_main(int argc, const char *argv[])\n+{\n+\t\t &test_reftable_stack_uptodate);\n+\t\t &test_reftable_stack_transaction_api);\n+\t\t &test_reftable_stack_hash_id);\n+\t\t &test_sizes_to_segments_all_equal);\n+\t\t &test_reftable_stack_auto_compaction);\n+\t\t &test_reftable_stack_validate_refname);\n+\t\t &test_reftable_stack_update_index_check);\n+\t\t &test_reftable_stack_lock_failure);\n+\t\t &test_reftable_stack_log_normalize);\n+\t\t &test_reftable_stack_tombstone);\n+\t\t &test_suggest_compaction_segment);\n+\t\t &test_suggest_compaction_segment_nothing);\n+\t\t &test_sizes_to_segments_empty);\n+\treturn test_main(argc, argv);\n+}\ndiff --git a/reftable/update.sh b/reftable/update.sh\nnew file mode 100755\n--- /dev/null\n+++ b/reftable/update.sh\n@@ -0,0 +1,22 @@\n+#!/bin/sh\n+\n+set -eu\n+\n+# Override this to import from somewhere else, say \"../reftable\".\n+SRC=\\${SRC:-origin}\n+BRANCH=\\${BRANCH:-master}\n+\n+((git --git-dir reftable-repo/.git fetch -f \\${SRC} \\${BRANCH}:import && cd reftable-repo && git checkout -f \\$(git rev-parse import) ) ||\n+\n+cp reftable-repo/c/*.[ch] reftable/\n+cp reftable-repo/c/include/*.[ch] reftable/\n+\n+git --git-dir reftable-repo/.git show --no-patch --format=oneline HEAD \\\n+ > reftable/VERSION\n+\n+mv reftable/system.h reftable/system.h~\n+sed 's|if REFTABLE_IN_GITCORE|if 1 /* REFTABLE_IN_GITCORE */|' < reftable/system.h~ > reftable/system.h\n+\ndiff --git a/t/helper/test-reftable.c b/t/helper/test-reftable.c\nindex 2273fdfe39..def8883439 100644\n--- a/t/helper/test-reftable.c\n+++ b/t/helper/test-reftable.c\n@@ -4,9 +4,12 @@\nint cmd__reftable(int argc, const char **argv)\n{\nblock_test_main(argc, argv);\n+\tmerged_test_main(argc, argv);\nrecord_test_main(argc, argv);\n+\trefname_test_main(argc, argv);\nreftable_test_main(argc, argv);\nstrbuf_test_main(argc, argv);\n+\tstack_test_main(argc, argv);\ntree_test_main(argc, argv);\nreturn 0;\n}\n--\n\n• ```* [PATCH 13/13] reftable: \"test-tool dump-reftable\" command.\n2020-09-16 19:10 [PATCH 00/13] reftable library Han-Wen Nienhuys via GitGitGadget\n` (11 preceding siblings ...)\n2020-09-16 19:10 ` [PATCH 12/13] reftable: rest of library Han-Wen Nienhuys via GitGitGadget\n@ 2020-09-16 19:10 ` Han-Wen Nienhuys via GitGitGadget\n2020-10-01 16:10 ` [PATCH v2 00/13] reftable library Han-Wen Nienhuys via GitGitGadget\n13 siblings, 0 replies; 251+ messages in thread\nFrom: Han-Wen Nienhuys via GitGitGadget @ 2020-09-16 19:10 UTC (permalink / raw)\nTo: git; +Cc: Han-Wen Nienhuys, Han-Wen Nienhuys\n\nThis command dumps individual tables or a stack of of tables.\n\n---\nMakefile | 2 ++\nt/helper/test-reftable.c | 5 +++++\nt/helper/test-tool.c | 1 +\nt/helper/test-tool.h | 1 +\n4 files changed, 9 insertions(+)\n\ndiff --git a/Makefile b/Makefile\nindex 6652259baf..ee82ff2915 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -2363,6 +2363,8 @@ REFTABLE_OBJS += reftable/writer.o\nREFTABLE_OBJS += reftable/zlib-compat.o\n\nREFTABLE_TEST_OBJS += reftable/block_test.o\n+REFTABLE_TEST_OBJS += reftable/dump.o\n+REFTABLE_TEST_OBJS += reftable/merged_test.o\nREFTABLE_TEST_OBJS += reftable/record_test.o\nREFTABLE_TEST_OBJS += reftable/refname_test.o\nREFTABLE_TEST_OBJS += reftable/reftable_test.o\ndiff --git a/t/helper/test-reftable.c b/t/helper/test-reftable.c\nindex def8883439..aff4fbccda 100644\n--- a/t/helper/test-reftable.c\n+++ b/t/helper/test-reftable.c\n@@ -13,3 +13,8 @@ int cmd__reftable(int argc, const char **argv)\ntree_test_main(argc, argv);\nreturn 0;\n}\n+\n+int cmd__dump_reftable(int argc, const char **argv)\n+{\n+\treturn reftable_dump_main(argc, (char *const *)argv);\n+}\ndiff --git a/t/helper/test-tool.c b/t/helper/test-tool.c\nindex 10366b7b76..9e689f9d2b 100644\n--- a/t/helper/test-tool.c\n+++ b/t/helper/test-tool.c\n@@ -53,6 +53,7 @@ static struct test_cmd cmds[] = {\n{ \"ref-store\", cmd__ref_store },\n{ \"reftable\", cmd__reftable },\n+\t{ \"dump-reftable\", cmd__dump_reftable },\n{ \"regex\", cmd__regex },\n{ \"repository\", cmd__repository },\n{ \"revision-walking\", cmd__revision_walking },\ndiff --git a/t/helper/test-tool.h b/t/helper/test-tool.h\nindex d52ba2f5e5..bf833e01d4 100644\n--- a/t/helper/test-tool.h\n+++ b/t/helper/test-tool.h\n@@ -17,6 +17,7 @@ int cmd__dump_cache_tree(int argc, const char **argv);\nint cmd__dump_fsmonitor(int argc, const char **argv);\nint cmd__dump_split_index(int argc, const char **argv);\nint cmd__dump_untracked_cache(int argc, const char **argv);\n+int cmd__dump_reftable(int argc, const char **argv);\nint cmd__example_decorate(int argc, const char **argv);\nint cmd__genrandom(int argc, const char **argv);\nint cmd__genzeros(int argc, const char **argv);\n--\n\n• ```* [PATCH v2 00/13] reftable library\n2020-09-16 19:10 [PATCH 00/13] reftable library Han-Wen Nienhuys via GitGitGadget\n` (12 preceding siblings ...)\n2020-09-16 19:10 ` [PATCH 13/13] reftable: \"test-tool dump-reftable\" command Han-Wen Nienhuys via GitGitGadget\n@ 2020-10-01 16:10 ` Han-Wen Nienhuys via GitGitGadget\n` (13 more replies)\n13 siblings, 14 replies; 251+ messages in thread\nFrom: Han-Wen Nienhuys via GitGitGadget @ 2020-10-01 16:10 UTC (permalink / raw)\nTo: git; +Cc: Han-Wen Nienhuys, Jeff King, Han-Wen Nienhuys\n\nThis splits the giant commit from\nhttps://github.com/gitgitgadget/git/pull/539 into a series of smaller\ncommits, which build and have unittests.\n\nThe final commit should also be split up, but I want to wait until we have\nconsensus that the bottom commits look good.\n\nHan-Wen Nienhuys (12):\nreftable: define the public API\nreftable: add a barebones unittest framework\nreftable: utility functions\nreftable: (de)serialization for the polymorphic record type.\nreftable: a generic binary tree implementation\nreftable: write reftable files\nreftable: file level tests\nreftable: rest of library\nreftable: \"test-tool dump-reftable\" command.\n\nJohannes Schindelin (1):\nvcxproj: adjust for the reftable changes\n\nMakefile | 46 +-\nconfig.mak.uname | 2 +-\ncontrib/buildsystems/Generators/Vcxproj.pm | 11 +-\nreftable/.gitattributes | 1 +\nreftable/VERSION | 1 +\nreftable/basics.c | 131 +++\nreftable/basics.h | 48 +\nreftable/block.c | 441 +++++++\nreftable/block.h | 129 ++\nreftable/block_test.c | 158 +++\nreftable/blocksource.c | 148 +++\nreftable/blocksource.h | 22 +\nreftable/compat.c | 110 ++\nreftable/compat.h | 48 +\nreftable/constants.h | 21 +\nreftable/dump.c | 212 ++++\nreftable/iter.c | 242 ++++\nreftable/iter.h | 72 ++\nreftable/merged.c | 358 ++++++\nreftable/merged.h | 36 +\nreftable/merged_test.c | 331 ++++++\nreftable/pq.c | 115 ++\nreftable/pq.h | 32 +\nreftable/publicbasics.c | 100 ++\nreftable/record.c | 1116 ++++++++++++++++++\nreftable/record.h | 137 +++\nreftable/record_test.c | 410 +++++++\nreftable/refname.c | 209 ++++\nreftable/refname.h | 28 +\nreftable/refname_test.c | 100 ++\nreftable/reftable-tests.h | 22 +\nreftable/reftable.c | 104 ++\nreftable/reftable.h | 585 +++++++++\nreftable/reftable_test.c | 585 +++++++++\nreftable/stack.c | 1240 ++++++++++++++++++++\nreftable/stack.h | 40 +\nreftable/stack_test.c | 788 +++++++++++++\nreftable/strbuf.c | 142 +++\nreftable/strbuf.h | 80 ++\nreftable/strbuf_test.c | 37 +\nreftable/system.h | 51 +\nreftable/test_framework.c | 68 ++\nreftable/test_framework.h | 59 +\nreftable/tree.c | 63 +\nreftable/tree.h | 34 +\nreftable/tree_test.c | 62 +\nreftable/update.sh | 22 +\nreftable/writer.c | 673 +++++++++++\nreftable/writer.h | 51 +\nreftable/zlib-compat.c | 92 ++\nt/helper/test-reftable.c | 20 +\nt/helper/test-tool.c | 2 +\nt/helper/test-tool.h | 2 +\n56 files changed, 10474 insertions(+), 5 deletions(-)\ncreate mode 100644 reftable/.gitattributes\ncreate mode 100644 reftable/VERSION\ncreate mode 100644 reftable/basics.c\ncreate mode 100644 reftable/basics.h\ncreate mode 100644 reftable/block.c\ncreate mode 100644 reftable/block.h\ncreate mode 100644 reftable/block_test.c\ncreate mode 100644 reftable/blocksource.c\ncreate mode 100644 reftable/blocksource.h\ncreate mode 100644 reftable/compat.c\ncreate mode 100644 reftable/compat.h\ncreate mode 100644 reftable/constants.h\ncreate mode 100644 reftable/dump.c\ncreate mode 100644 reftable/iter.c\ncreate mode 100644 reftable/iter.h\ncreate mode 100644 reftable/merged.c\ncreate mode 100644 reftable/merged.h\ncreate mode 100644 reftable/merged_test.c\ncreate mode 100644 reftable/pq.c\ncreate mode 100644 reftable/pq.h\ncreate mode 100644 reftable/publicbasics.c\ncreate mode 100644 reftable/record.c\ncreate mode 100644 reftable/record.h\ncreate mode 100644 reftable/record_test.c\ncreate mode 100644 reftable/refname.c\ncreate mode 100644 reftable/refname.h\ncreate mode 100644 reftable/refname_test.c\ncreate mode 100644 reftable/reftable-tests.h\ncreate mode 100644 reftable/reftable.c\ncreate mode 100644 reftable/reftable.h\ncreate mode 100644 reftable/reftable_test.c\ncreate mode 100644 reftable/stack.c\ncreate mode 100644 reftable/stack.h\ncreate mode 100644 reftable/stack_test.c\ncreate mode 100644 reftable/strbuf.c\ncreate mode 100644 reftable/strbuf.h\ncreate mode 100644 reftable/strbuf_test.c\ncreate mode 100644 reftable/system.h\ncreate mode 100644 reftable/test_framework.c\ncreate mode 100644 reftable/test_framework.h\ncreate mode 100644 reftable/tree.c\ncreate mode 100644 reftable/tree.h\ncreate mode 100644 reftable/tree_test.c\ncreate mode 100755 reftable/update.sh\ncreate mode 100644 reftable/writer.c\ncreate mode 100644 reftable/writer.h\ncreate mode 100644 reftable/zlib-compat.c\ncreate mode 100644 t/helper/test-reftable.c\n\nPull-Request: https://github.com/git/git/pull/847\n\nRange-diff vs v1:\n\n2: e2dbc84833 = 2: 5d1b946ab5 reftable: define the public API\n3: 0f6efc065c = 3: 01a669a731 vcxproj: adjust for the reftable changes\n4: 7bf59d491d ! 4: b94c5f5c61 reftable: add a barebones unittest framework\n@@ reftable/test_framework.c (new)\n+#include \"system.h\"\n+#include \"basics.h\"\n+\n-+struct test_case **test_cases;\n-+int test_case_len;\n-+int test_case_cap;\n++static struct test_case **test_cases;\n++static int test_case_len;\n++static int test_case_cap;\n+\n-+struct test_case *new_test_case(const char *name, void (*testfunc)(void))\n++static struct test_case *new_test_case(const char *name, void (*testfunc)(void))\n+{\n+\tstruct test_case *tc = reftable_malloc(sizeof(struct test_case));\n+\ttc->name = name;\n@@ reftable/test_framework.c (new)\n+\t\treftable_free(test_cases[i]);\n+\t}\n+\treftable_free(test_cases);\n-+\ttest_cases = 0;\n++\ttest_cases = NULL;\n+\ttest_case_len = 0;\n+\ttest_case_cap = 0;\n+\treturn 0;\n@@ reftable/test_framework.h (new)\n+\tvoid (*testfunc)(void);\n+};\n+\n-+struct test_case *new_test_case(const char *name, void (*testfunc)(void));\n+struct test_case *add_test_case(const char *name, void (*testfunc)(void));\n+int test_main(int argc, const char *argv[]);\n+\n5: 570a8c4bca ! 5: 4190da597e reftable: utility functions\n@@ reftable/blocksource.c (new)\n+\treturn ((struct strbuf *)b)->len;\n+}\n+\n-+struct reftable_block_source_vtable strbuf_vtable = {\n++static struct reftable_block_source_vtable strbuf_vtable = {\n+\t.size = &strbuf_size,\n+\t.return_block = &strbuf_return_block,\n@@ reftable/blocksource.c (new)\n+\treftable_free(dest->data);\n+}\n+\n-+struct reftable_block_source_vtable malloc_vtable = {\n++static struct reftable_block_source_vtable malloc_vtable = {\n+\t.return_block = &malloc_return_block,\n+};\n+\n-+struct reftable_block_source malloc_block_source_instance = {\n++static struct reftable_block_source malloc_block_source_instance = {\n+\t.ops = &malloc_vtable,\n+};\n+\n@@ reftable/blocksource.c (new)\n+\treturn size;\n+}\n+\n-+struct reftable_block_source_vtable file_vtable = {\n++static struct reftable_block_source_vtable file_vtable = {\n+\t.size = &file_size,\n+\t.return_block = &file_return_block,\n@@ reftable/publicbasics.c (new)\n+\t}\n+}\n+\n-+void *(*reftable_malloc_ptr)(size_t sz) = &malloc;\n-+void *(*reftable_realloc_ptr)(void *, size_t) = &realloc;\n-+void (*reftable_free_ptr)(void *) = &free;\n++static void *(*reftable_malloc_ptr)(size_t sz) = &malloc;\n++static void *(*reftable_realloc_ptr)(void *, size_t) = &realloc;\n++static void (*reftable_free_ptr)(void *) = &free;\n+\n+void *reftable_malloc(size_t sz)\n+{\n6: 791f69c000 ! 6: 8eb944ea9b reftable: (de)serialization for the polymorphic record type.\n@@ reftable/record.c (new)\n+\t\t(const struct reftable_ref_record *)p);\n+}\n+\n-+struct reftable_record_vtable reftable_ref_record_vtable = {\n++static struct reftable_record_vtable reftable_ref_record_vtable = {\n+\t.key = &reftable_ref_record_key,\n+\t.type = BLOCK_TYPE_REF,\n+\t.copy_from = &reftable_ref_record_copy_from,\n@@ reftable/record.c (new)\n+\treturn 0;\n+}\n+\n-+struct reftable_record_vtable reftable_obj_record_vtable = {\n++static struct reftable_record_vtable reftable_obj_record_vtable = {\n+\t.key = &reftable_obj_record_key,\n+\t.type = BLOCK_TYPE_OBJ,\n+\t.copy_from = &reftable_obj_record_copy_from,\n@@ reftable/record.c (new)\n+\t\t(const struct reftable_log_record *)p);\n+}\n+\n-+struct reftable_record_vtable reftable_log_record_vtable = {\n++static struct reftable_record_vtable reftable_log_record_vtable = {\n+\t.key = &reftable_log_record_key,\n+\t.type = BLOCK_TYPE_LOG,\n+\t.copy_from = &reftable_log_record_copy_from,\n@@ reftable/record.c (new)\n+\treturn rec;\n+}\n+\n-+void *reftable_record_yield(struct reftable_record *rec)\n++/* clear out the record, yielding the reftable_record data that was\n++ * encapsulated. */\n++static void *reftable_record_yield(struct reftable_record *rec)\n+{\n+\tvoid *p = rec->data;\n+\trec->data = NULL;\n@@ reftable/record.c (new)\n+\treturn start.len - in.len;\n+}\n+\n-+struct reftable_record_vtable reftable_index_record_vtable = {\n++static struct reftable_record_vtable reftable_index_record_vtable = {\n+\t.key = &reftable_index_record_key,\n+\t.type = BLOCK_TYPE_INDEX,\n+\t.copy_from = &reftable_index_record_copy_from,\n@@ reftable/record.h (new)\n+/* creates a malloced record of the given type. Dispose with record_destroy */\n+struct reftable_record reftable_new_record(uint8_t typ);\n+\n-+extern struct reftable_record_vtable reftable_ref_record_vtable;\n-+\n+/* Encode `key` into `dest`. Sets `is_restart` to indicate a restart. Returns\n+ number of bytes written. */\n+int reftable_encode_key(int *is_restart, struct string_view dest,\n@@ reftable/record.h (new)\n+/* zeroes out the embedded record */\n+void reftable_record_clear(struct reftable_record *rec);\n+\n-+/* clear out the record, yielding the reftable_record data that was\n-+ * encapsulated. */\n-+void *reftable_record_yield(struct reftable_record *rec);\n-+\n+/* clear and deallocate embedded record, and zero `rec`. */\n+void reftable_record_destroy(struct reftable_record *rec);\n+\n@@ reftable/record_test.c (new)\n+\tint i = 0;\n+\n+\tfor (i = 0; i <= 3; i++) {\n-+\t\tstruct reftable_ref_record in = { 0 };\n++\t\tstruct reftable_ref_record in = { NULL };\n+\t\tstruct reftable_ref_record out = {\n+\t\t\t.refname = xstrdup(\"old name\"),\n+\t\t\t.value = reftable_calloc(SHA1_SIZE),\n+\t\t\t.target_value = reftable_calloc(SHA1_SIZE),\n+\t\t\t.target = xstrdup(\"old value\"),\n+\t\t};\n-+\t\tstruct reftable_record rec_out = { 0 };\n++\t\tstruct reftable_record rec_out = { NULL };\n+\t\tstruct strbuf key = STRBUF_INIT;\n-+\t\tstruct reftable_record rec = { 0 };\n++\t\tstruct reftable_record rec = { NULL };\n+\t\tuint8_t buffer = { 0 };\n+\t\tstruct string_view dest = {\n+\t\t\t.buf = buffer,\n@@ reftable/record_test.c (new)\n+\tset_test_hash(in.new_hash, 1);\n+\tset_test_hash(in.old_hash, 2);\n+\tfor (int i = 0; i < ARRAY_SIZE(in); i++) {\n-+\t\tstruct reftable_record rec = { 0 };\n++\t\tstruct reftable_record rec = { NULL };\n+\t\tstruct strbuf key = STRBUF_INIT;\n+\t\tuint8_t buffer = { 0 };\n+\t\tstruct string_view dest = {\n@@ reftable/record_test.c (new)\n+\t\t\t.email = xstrdup(\"old@email\"),\n+\t\t\t.message = xstrdup(\"old message\"),\n+\t\t};\n-+\t\tstruct reftable_record rec_out = { 0 };\n++\t\tstruct reftable_record rec_out = { NULL };\n+\t\tint n, m, valtype;\n+\n+\t\treftable_record_from_log(&rec, &in[i]);\n@@ reftable/record_test.c (new)\n+\t\t\t.buf = buffer,\n+\t\t\t.len = sizeof(buffer),\n+\t\t};\n-+\t\tstruct reftable_record rec = { 0 };\n++\t\tstruct reftable_record rec = { NULL };\n+\t\tstruct strbuf key = STRBUF_INIT;\n-+\t\tstruct reftable_obj_record out = { 0 };\n-+\t\tstruct reftable_record rec_out = { 0 };\n++\t\tstruct reftable_obj_record out = { NULL };\n++\t\tstruct reftable_record rec_out = { NULL };\n+\t\tint n, m;\n+\t\tuint8_t extra;\n+\n@@ reftable/record_test.c (new)\n+\t\t.len = sizeof(buffer),\n+\t};\n+\tstruct strbuf key = STRBUF_INIT;\n-+\tstruct reftable_record rec = { 0 };\n++\tstruct reftable_record rec = { NULL };\n+\tstruct reftable_index_record out = { .last_key = STRBUF_INIT };\n+\tstruct reftable_record out_rec = { NULL };\n+\tint n, m;\n7: 1ba8e3eb30 ! 7: 757dd30fe2 reftable: reading/writing blocks\n@@ reftable/block.c (new)\n+\tabort();\n+}\n+\n-+int block_writer_register_restart(struct block_writer *w, int n, int restart,\n-+\t\t\t\t struct strbuf *key);\n++static int block_writer_register_restart(struct block_writer *w, int n,\n++\t\t\t\t\t int is_restart, struct strbuf *key)\n++{\n++\tint rlen = w->restart_len;\n++\tif (rlen >= MAX_RESTARTS) {\n++\t\tis_restart = 0;\n++\t}\n++\n++\tif (is_restart) {\n++\t\trlen++;\n++\t}\n++\tif (2 + 3 * rlen + n > w->block_size - w->next)\n++\t\treturn -1;\n++\tif (is_restart) {\n++\t\tif (w->restart_len == w->restart_cap) {\n++\t\t\tw->restart_cap = w->restart_cap * 2 + 1;\n++\t\t\tw->restarts = reftable_realloc(\n++\t\t\t\tw->restarts, sizeof(uint32_t) * w->restart_cap);\n++\t\t}\n++\n++\t\tw->restarts[w->restart_len++] = w->next;\n++\t}\n++\n++\tw->next += n;\n++\n++\tstrbuf_reset(&w->last_key);\n++\tw->entries++;\n++\treturn 0;\n++}\n+\n+void block_writer_init(struct block_writer *bw, uint8_t typ, uint8_t *buf,\n+\t\t uint32_t block_size, uint32_t header_off, int hash_size)\n@@ reftable/block.c (new)\n+\treturn -1;\n+}\n+\n-+int block_writer_register_restart(struct block_writer *w, int n, int is_restart,\n-+\t\t\t\t struct strbuf *key)\n-+{\n-+\tint rlen = w->restart_len;\n-+\tif (rlen >= MAX_RESTARTS) {\n-+\t\tis_restart = 0;\n-+\t}\n-+\n-+\tif (is_restart) {\n-+\t\trlen++;\n-+\t}\n-+\tif (2 + 3 * rlen + n > w->block_size - w->next)\n-+\t\treturn -1;\n-+\tif (is_restart) {\n-+\t\tif (w->restart_len == w->restart_cap) {\n-+\t\t\tw->restart_cap = w->restart_cap * 2 + 1;\n-+\t\t\tw->restarts = reftable_realloc(\n-+\t\t\t\tw->restarts, sizeof(uint32_t) * w->restart_cap);\n-+\t\t}\n-+\n-+\t\tw->restarts[w->restart_len++] = w->next;\n-+\t}\n-+\n-+\tw->next += n;\n-+\n-+\tstrbuf_reset(&w->last_key);\n-+\tw->entries++;\n-+\treturn 0;\n-+}\n+\n+int block_writer_finish(struct block_writer *w)\n+{\n@@ reftable/block_test.c (new)\n+\tchar *names;\n+\tconst int N = ARRAY_SIZE(names);\n+\tconst int block_size = 1024;\n-+\tstruct reftable_block block = { 0 };\n++\tstruct reftable_block block = { NULL };\n+\tstruct block_writer bw = {\n+\t\t.last_key = STRBUF_INIT,\n+\t};\n-+\tstruct reftable_ref_record ref = { 0 };\n-+\tstruct reftable_record rec = { 0 };\n++\tstruct reftable_ref_record ref = { NULL };\n++\tstruct reftable_record rec = { NULL };\n+\tint i = 0;\n+\tint n;\n+\tstruct block_reader br = { 0 };\n8: 17fb8d050d ! 8: e30a7e0281 reftable: a generic binary tree implementation\n@@ reftable/tree_test.c (new)\n+{\n+\tstruct tree_node *root = NULL;\n+\n-+\tvoid *values = { 0 };\n-+\tstruct tree_node *nodes = { 0 };\n++\tvoid *values = { NULL };\n++\tstruct tree_node *nodes = { NULL };\n+\tint i = 1;\n-+\tstruct curry c = { 0 };\n++\tstruct curry c = { NULL };\n+\tdo {\n+\t\tnodes[i] = tree_search(values + i, &root, &test_compare, 1);\n+\t\ti = (i * 7) % 11;\n9: 4e40fc3b40 ! 9: 68aee16e60 reftable: write reftable files\n@@ reftable/writer.c (new)\n+#include \"reftable.h\"\n+#include \"tree.h\"\n+\n++/* finishes a block, and writes it to storage */\n++static int writer_flush_block(struct reftable_writer *w);\n++\n++/* deallocates memory related to the index */\n++static void writer_clear_index(struct reftable_writer *w);\n++\n++/* finishes writing a 'r' (refs) or 'g' (reflogs) section */\n++static int writer_finish_public_section(struct reftable_writer *w);\n++\n+static struct reftable_block_stats *\n+writer_reftable_block_stats(struct reftable_writer *w, uint8_t typ)\n+{\n@@ reftable/writer.c (new)\n+\t\t\t struct reftable_ref_record *ref)\n+{\n-+\tstruct reftable_record rec = { 0 };\n++\tstruct reftable_record rec = { NULL };\n+\tstruct reftable_ref_record copy = *ref;\n+\tint err = 0;\n+\n@@ reftable/writer.c (new)\n+\t\t\t struct reftable_log_record *log)\n+{\n-+\tstruct reftable_record rec = { 0 };\n++\tstruct reftable_record rec = { NULL };\n+\tchar *input_log_message = log->message;\n+\tstruct strbuf cleaned_message = STRBUF_INIT;\n+\tint err;\n@@ reftable/writer.c (new)\n+\t\tw->index_len = 0;\n+\t\tw->index_cap = 0;\n+\t\tfor (i = 0; i < idx_len; i++) {\n-+\t\t\tstruct reftable_record rec = { 0 };\n++\t\t\tstruct reftable_record rec = { NULL };\n+\t\t\treftable_record_from_index(&rec, idx + i);\n+\t\t\tif (block_writer_add(w->block_writer, &rec) == 0) {\n+\t\t\t\tcontinue;\n@@ reftable/writer.c (new)\n+\t\t.offsets = entry->offsets,\n+\t\t.offset_len = entry->offset_len,\n+\t};\n-+\tstruct reftable_record rec = { 0 };\n++\tstruct reftable_record rec = { NULL };\n+\tif (arg->err < 0)\n+\t\tgoto done;\n+\n@@ reftable/writer.c (new)\n+static int writer_dump_object_index(struct reftable_writer *w)\n+{\n+\tstruct write_record_arg closure = { .w = w };\n-+\tstruct common_prefix_arg common = { 0 };\n++\tstruct common_prefix_arg common = { NULL };\n+\tif (w->obj_index_tree != NULL) {\n+\t\tinfix_walk(w->obj_index_tree, &update_common, &common);\n+\t}\n@@ reftable/writer.c (new)\n+\treturn writer_finish_section(w);\n+}\n+\n-+int writer_finish_public_section(struct reftable_writer *w)\n++static int writer_finish_public_section(struct reftable_writer *w)\n+{\n+\tuint8_t typ = 0;\n+\tint err = 0;\n@@ reftable/writer.c (new)\n+\treturn err;\n+}\n+\n-+void writer_clear_index(struct reftable_writer *w)\n++static void writer_clear_index(struct reftable_writer *w)\n+{\n+\tint i = 0;\n+\tfor (i = 0; i < w->index_len; i++) {\n@@ reftable/writer.c (new)\n+\tw->index_cap = 0;\n+}\n+\n-+const int debug = 0;\n++static const int debug = 0;\n+\n+static int writer_flush_nonempty_block(struct reftable_writer *w)\n+{\n@@ reftable/writer.c (new)\n+\treturn 0;\n+}\n+\n-+int writer_flush_block(struct reftable_writer *w)\n++static int writer_flush_block(struct reftable_writer *w)\n+{\n+\tif (w->block_writer == NULL)\n+\t\treturn 0;\n@@ reftable/writer.h (new)\n+\tstruct reftable_stats stats;\n+};\n+\n-+/* finishes a block, and writes it to storage */\n-+int writer_flush_block(struct reftable_writer *w);\n-+\n-+/* deallocates memory related to the index */\n-+void writer_clear_index(struct reftable_writer *w);\n-+\n-+/* finishes writing a 'r' (refs) or 'g' (reflogs) section */\n-+int writer_finish_public_section(struct reftable_writer *w);\n-+\n+#endif\n10: 25259b683b ! 10: c196de7f06 reftable: read reftable files\n@@ reftable/iter.c (new)\n+{\n+}\n+\n-+struct reftable_iterator_vtable empty_vtable = {\n++static struct reftable_iterator_vtable empty_vtable = {\n+\t.next = &empty_iterator_next,\n+\t.close = &empty_iterator_close,\n+};\n@@ reftable/iter.c (new)\n+\treturn err;\n+}\n+\n-+struct reftable_iterator_vtable filtering_ref_iterator_vtable = {\n++static struct reftable_iterator_vtable filtering_ref_iterator_vtable = {\n+\t.next = &filtering_ref_iterator_next,\n+\t.close = &filtering_ref_iterator_close,\n+};\n@@ reftable/iter.c (new)\n+\treturn err;\n+}\n+\n-+struct reftable_iterator_vtable indexed_table_ref_iter_vtable = {\n++static struct reftable_iterator_vtable indexed_table_ref_iter_vtable = {\n+\t.next = &indexed_table_ref_iter_next,\n+\t.close = &indexed_table_ref_iter_close,\n+};\n+\tblock_iter_close(&ti->bi);\n+}\n+\n-+struct reftable_iterator_vtable table_iter_vtable = {\n++static struct reftable_iterator_vtable table_iter_vtable = {\n+\t.next = &table_iter_next_void,\n+\t.close = &table_iter_close,\n+};\n11: 3448fcf828 ! 11: bf6b929b86 reftable: file level tests\n@@ reftable/reftable_test.c (new)\n+{\n+\tstruct strbuf buf = STRBUF_INIT;\n+\tstruct reftable_block_source source = { NULL };\n-+\tstruct reftable_block out = { 0 };\n++\tstruct reftable_block out = { NULL };\n+\tint n;\n+\tuint8_t in[] = \"hello\";\n@@ reftable/reftable_test.c (new)\n+\t};\n+\tstruct reftable_writer *w =\n-+\tstruct reftable_ref_record ref = { 0 };\n++\tstruct reftable_ref_record ref = { NULL };\n+\tint i = 0, n;\n-+\tstruct reftable_log_record log = { 0 };\n++\tstruct reftable_log_record log = { NULL };\n+\tconst struct reftable_stats *stats = NULL;\n+\t*names = reftable_calloc(sizeof(char *) * (N + 1));\n+\treftable_writer_set_limits(w, update_index, update_index);\n@@ reftable/reftable_test.c (new)\n+\tstruct reftable_write_options opts = {\n+\t\t.block_size = 256,\n+\t};\n-+\tstruct reftable_ref_record ref = { 0 };\n++\tstruct reftable_ref_record ref = { NULL };\n+\tint i = 0;\n-+\tstruct reftable_log_record log = { 0 };\n++\tstruct reftable_log_record log = { NULL };\n+\tint n;\n-+\tstruct reftable_iterator it = { 0 };\n-+\tstruct reftable_reader rd = { 0 };\n-+\tstruct reftable_block_source source = { 0 };\n++\tstruct reftable_iterator it = { NULL };\n++\tstruct reftable_reader rd = { NULL };\n++\tstruct reftable_block_source source = { NULL };\n+\tstruct strbuf buf = STRBUF_INIT;\n+\tstruct reftable_writer *w =\n@@ reftable/reftable_test.c (new)\n+\treftable_writer_set_limits(w, 0, N);\n+\tfor (i = 0; i < N; i++) {\n+\t\tchar name;\n-+\t\tstruct reftable_ref_record ref = { 0 };\n++\t\tstruct reftable_ref_record ref = { NULL };\n+\t\tsnprintf(name, sizeof(name), \"b%02d%0*d\", i, 130, 7);\n+\t\tnames[i] = xstrdup(name);\n+\t\tref.refname = name;\n@@ reftable/reftable_test.c (new)\n+\t}\n+\tfor (i = 0; i < N; i++) {\n+\t\tuint8_t hash1[SHA1_SIZE], hash2[SHA1_SIZE];\n-+\t\tstruct reftable_log_record log = { 0 };\n++\t\tstruct reftable_log_record log = { NULL };\n+\t\tset_test_hash(hash1, i);\n+\t\tset_test_hash(hash2, i + 1);\n+\n@@ reftable/reftable_test.c (new)\n+\tchar **names;\n+\tstruct strbuf buf = STRBUF_INIT;\n+\tint N = 50;\n-+\tstruct reftable_iterator it = { 0 };\n-+\tstruct reftable_block_source source = { 0 };\n-+\tstruct reftable_reader rd = { 0 };\n++\tstruct reftable_iterator it = { NULL };\n++\tstruct reftable_block_source source = { NULL };\n++\tstruct reftable_reader rd = { NULL };\n+\tint err = 0;\n+\tint j = 0;\n+\n@@ reftable/reftable_test.c (new)\n+\tassert_err(err);\n+\n+\twhile (1) {\n-+\t\tstruct reftable_ref_record ref = { 0 };\n++\t\tstruct reftable_ref_record ref = { NULL };\n+\t\tint r = reftable_iterator_next_ref(&it, &ref);\n+\t\tassert(r >= 0);\n+\t\tif (r > 0) {\n@@ reftable/reftable_test.c (new)\n+\tchar **names;\n+\tstruct strbuf buf = STRBUF_INIT;\n+\tint N = 50;\n-+\tstruct reftable_reader rd = { 0 };\n-+\tstruct reftable_block_source source = { 0 };\n++\tstruct reftable_reader rd = { NULL };\n++\tstruct reftable_block_source source = { NULL };\n+\tint err;\n+\tint i;\n-+\tstruct reftable_log_record log = { 0 };\n-+\tstruct reftable_iterator it = { 0 };\n++\tstruct reftable_log_record log = { NULL };\n++\tstruct reftable_iterator it = { NULL };\n+\n+\twrite_table(&names, &buf, N, 256, SHA1_ID);\n+\n@@ reftable/reftable_test.c (new)\n+\tchar **names;\n+\tstruct strbuf buf = STRBUF_INIT;\n+\tint N = 50;\n-+\tstruct reftable_reader rd = { 0 };\n-+\tstruct reftable_block_source source = { 0 };\n++\tstruct reftable_reader rd = { NULL };\n++\tstruct reftable_block_source source = { NULL };\n+\tint err;\n+\tint i = 0;\n+\n-+\tstruct reftable_iterator it = { 0 };\n++\tstruct reftable_iterator it = { NULL };\n+\tstruct strbuf pastLast = STRBUF_INIT;\n-+\tstruct reftable_ref_record ref = { 0 };\n++\tstruct reftable_ref_record ref = { NULL };\n+\n+\twrite_table(&names, &buf, N, 256, hash_id);\n+\n@@ reftable/reftable_test.c (new)\n+\n+\terr = reftable_reader_seek_ref(&rd, &it, pastLast.buf);\n+\tif (err == 0) {\n-+\t\tstruct reftable_ref_record ref = { 0 };\n++\t\tstruct reftable_ref_record ref = { NULL };\n+\t\tint err = reftable_iterator_next_ref(&it, &ref);\n+\t\tassert(err > 0);\n+\t} else {\n@@ reftable/reftable_test.c (new)\n+\tstruct reftable_write_options opts = {\n+\t\t.block_size = 256,\n+\t};\n-+\tstruct reftable_ref_record ref = { 0 };\n++\tstruct reftable_ref_record ref = { NULL };\n+\tint i = 0;\n+\tint n;\n+\tint err;\n-+\tstruct reftable_block_source source = { 0 };\n++\tstruct reftable_block_source source = { NULL };\n+\n+\tstruct strbuf buf = STRBUF_INIT;\n+\tstruct reftable_writer *w =\n+\n-+\tstruct reftable_iterator it = { 0 };\n++\tstruct reftable_iterator it = { NULL };\n+\tint j;\n+\n+\tset_test_hash(want_hash, 4);\n@@ reftable/reftable_test.c (new)\n+\t\tchar name;\n+\t\tuint8_t hash1[SHA1_SIZE];\n+\t\tuint8_t hash2[SHA1_SIZE];\n-+\t\tstruct reftable_ref_record ref = { 0 };\n++\t\tstruct reftable_ref_record ref = { NULL };\n+\n+\t\tmemset(hash, i, sizeof(hash));\n+\t\tmemset(fill, 'x', 50);\n@@ reftable/reftable_test.c (new)\n+\tstruct strbuf buf = STRBUF_INIT;\n+\tstruct reftable_writer *w =\n-+\tstruct reftable_block_source source = { 0 };\n++\tstruct reftable_block_source source = { NULL };\n+\tstruct reftable_reader *rd = NULL;\n-+\tstruct reftable_ref_record rec = { 0 };\n-+\tstruct reftable_iterator it = { 0 };\n++\tstruct reftable_ref_record rec = { NULL };\n++\tstruct reftable_iterator it = { NULL };\n+\tint err;\n+\n+\treftable_writer_set_limits(w, 1, 1);\n12: 64d98e60b2 ! 12: 4e38db7f48 reftable: rest of library\n@@ Makefile: REFTABLE_OBJS += reftable/zlib-compat.o\n\n## reftable/VERSION (new) ##\n@@\n++7134eb9f8171a9759800f4187f9e6dde997335e7 C: NULL iso 0 for init\n\n## reftable/dump.c (new) ##\n@@\n@@ reftable/dump.c (new)\n+\n+static int dump_table(const char *tablename)\n+{\n-+\tstruct reftable_block_source src = { 0 };\n++\tstruct reftable_block_source src = { NULL };\n+\tint err = reftable_block_source_from_file(&src, tablename);\n-+\tstruct reftable_iterator it = { 0 };\n-+\tstruct reftable_ref_record ref = { 0 };\n-+\tstruct reftable_log_record log = { 0 };\n++\tstruct reftable_iterator it = { NULL };\n++\tstruct reftable_ref_record ref = { NULL };\n++\tstruct reftable_log_record log = { NULL };\n+\tstruct reftable_reader *r = NULL;\n+\n+\tif (err < 0)\n@@ reftable/dump.c (new)\n+{\n+\tstruct reftable_stack *stack = NULL;\n+\tstruct reftable_write_options cfg = {};\n-+\tstruct reftable_iterator it = { 0 };\n-+\tstruct reftable_ref_record ref = { 0 };\n-+\tstruct reftable_log_record log = { 0 };\n++\tstruct reftable_iterator it = { NULL };\n++\tstruct reftable_ref_record ref = { NULL };\n++\tstruct reftable_log_record log = { NULL };\n+\tstruct reftable_merged_table *merged = NULL;\n+\n+\tint err = reftable_new_stack(&stack, stackdir, cfg);\n@@ reftable/merged.c (new)\n+\treturn merged_iter_next(mi, rec);\n+}\n+\n-+struct reftable_iterator_vtable merged_iter_vtable = {\n++static struct reftable_iterator_vtable merged_iter_vtable = {\n+\t.next = &merged_iter_next_void,\n+\t.close = &merged_iter_close,\n+};\n@@ reftable/merged.c (new)\n+\treturn mt->min;\n+}\n+\n-+int merged_table_seek_record(struct reftable_merged_table *mt,\n-+\t\t\t struct reftable_iterator *it,\n-+\t\t\t struct reftable_record *rec)\n++static int merged_table_seek_record(struct reftable_merged_table *mt,\n++\t\t\t\t struct reftable_iterator *it,\n++\t\t\t\t struct reftable_record *rec)\n+{\n+\tstruct reftable_iterator *iters = reftable_calloc(\n+\t\tsizeof(struct reftable_iterator) * mt->stack_len);\n@@ reftable/merged.c (new)\n+\tstruct reftable_ref_record ref = {\n+\t\t.refname = (char *)name,\n+\t};\n-+\tstruct reftable_record rec = { 0 };\n++\tstruct reftable_record rec = { NULL };\n+\treftable_record_from_ref(&rec, &ref);\n+\treturn merged_table_seek_record(mt, it, &rec);\n+}\n@@ reftable/merged.c (new)\n+\t\t.refname = (char *)name,\n+\t\t.update_index = update_index,\n+\t};\n-+\tstruct reftable_record rec = { 0 };\n++\tstruct reftable_record rec = { NULL };\n+\treftable_record_from_log(&rec, &log);\n+\treturn merged_table_seek_record(mt, it, &rec);\n+}\n@@ reftable/merged.h (new)\n+};\n+\n+void merged_table_clear(struct reftable_merged_table *mt);\n-+int merged_table_seek_record(struct reftable_merged_table *mt,\n-+\t\t\t struct reftable_iterator *it,\n-+\t\t\t struct reftable_record *rec);\n+\n+#endif\n\n@@ reftable/merged_test.c (new)\n+\n+static void test_pq(void)\n+{\n-+\tchar *names = { 0 };\n++\tchar *names = { NULL };\n+\tint N = ARRAY_SIZE(names) - 1;\n+\n-+\tstruct merged_iter_pqueue pq = { 0 };\n++\tstruct merged_iter_pqueue pq = { NULL };\n+\tconst char *last = NULL;\n+\n+\tint i = 0;\n@@ reftable/merged_test.c (new)\n+\tstruct reftable_merged_table *mt =\n+\t\tmerged_table_from_records(refs, &bs, &readers, sizes, bufs, 2);\n+\tint i;\n-+\tstruct reftable_ref_record ref = { 0 };\n-+\tstruct reftable_iterator it = { 0 };\n++\tstruct reftable_ref_record ref = { NULL };\n++\tstruct reftable_iterator it = { NULL };\n+\tint err = reftable_merged_table_seek_ref(mt, &it, \"a\");\n+\tassert_err(err);\n+\n@@ reftable/merged_test.c (new)\n+\tstruct reftable_merged_table *mt =\n+\t\tmerged_table_from_records(refs, &bs, &readers, sizes, bufs, 3);\n+\n-+\tstruct reftable_iterator it = { 0 };\n++\tstruct reftable_iterator it = { NULL };\n+\tint err = reftable_merged_table_seek_ref(mt, &it, \"a\");\n+\tstruct reftable_ref_record *out = NULL;\n+\tsize_t len = 0;\n@@ reftable/merged_test.c (new)\n+\n+\tassert_err(err);\n+\twhile (len < 100) { /* cap loops/recursion. */\n-+\t\tstruct reftable_ref_record ref = { 0 };\n++\t\tstruct reftable_ref_record ref = { NULL };\n+\t\tint err = reftable_iterator_next_ref(&it, &ref);\n+\t\tif (err > 0) {\n+\t\t\tbreak;\n@@ reftable/merged_test.c (new)\n+\t\t.update_index = 1,\n+\t};\n+\tint err;\n-+\tstruct reftable_block_source source = { 0 };\n++\tstruct reftable_block_source source = { NULL };\n+\tstruct reftable_table *tab = reftable_calloc(sizeof(*tab) * 1);\n+\tuint32_t hash_id;\n+\tstruct reftable_reader *rd = NULL;\n@@ reftable/pq.c (new)\n+#include \"system.h\"\n+#include \"basics.h\"\n+\n-+int pq_less(struct pq_entry a, struct pq_entry b)\n++static int pq_less(struct pq_entry a, struct pq_entry b)\n+{\n+\tstruct strbuf ak = STRBUF_INIT;\n+\tstruct strbuf bk = STRBUF_INIT;\n@@ reftable/pq.h (new)\n+\tstruct reftable_record rec;\n+};\n+\n-+int pq_less(struct pq_entry a, struct pq_entry b);\n-+\n+struct merged_iter_pqueue {\n+\tstruct pq_entry *heap;\n+\tsize_t len;\n@@ reftable/refname.c (new)\n+\treturn strcmp(f_arg->names[k], f_arg->want) >= 0;\n+}\n+\n-+int modification_has_ref(struct modification *mod, const char *name)\n++static int modification_has_ref(struct modification *mod, const char *name)\n+{\n-+\tstruct reftable_ref_record ref = { 0 };\n++\tstruct reftable_ref_record ref = { NULL };\n+\tint err = 0;\n+\n+\tif (mod->add_len > 0) {\n@@ reftable/refname.c (new)\n+\tmod->del_len = 0;\n+}\n+\n-+int modification_has_ref_with_prefix(struct modification *mod,\n-+\t\t\t\t const char *prefix)\n++static int modification_has_ref_with_prefix(struct modification *mod,\n++\t\t\t\t\t const char *prefix)\n+{\n+\tstruct reftable_iterator it = { NULL };\n+\tstruct reftable_ref_record ref = { NULL };\n@@ reftable/refname.c (new)\n+\treturn err;\n+}\n+\n-+int validate_refname(const char *name)\n++static int validate_refname(const char *name)\n+{\n+\twhile (1) {\n+\t\tchar *next = strchr(name, '/');\n@@ reftable/refname.h (new)\n+\tsize_t del_len;\n+};\n+\n-+int modification_has_ref(struct modification *mod, const char *name);\n-+\n-+int modification_has_ref_with_prefix(struct modification *mod,\n-+\t\t\t\t const char *prefix);\n-+\n-+// 0 = OK.\n-+int validate_refname(const char *name);\n-+\n+\t\t\t\t struct reftable_ref_record *recs, size_t sz);\n+\n@@ reftable/refname_test.c (new)\n+\t};\n+\tint err;\n+\tint i;\n-+\tstruct reftable_block_source source = { 0 };\n++\tstruct reftable_block_source source = { NULL };\n+\tstruct reftable_reader *rd = NULL;\n+\tstruct reftable_table tab = { NULL };\n+\tstruct testcase cases[] = {\n@@ reftable/refname_test.c (new)\n+\treturn test_main(argc, argv);\n+}\n\n+ ## reftable/reftable.c ##\n+@@ reftable/reftable.c: int reftable_table_seek_ref(struct reftable_table *tab,\n+ \tstruct reftable_ref_record ref = {\n+ \t\t.refname = (char *)name,\n+ \t};\n+-\tstruct reftable_record rec = { 0 };\n++\tstruct reftable_record rec = { NULL };\n+ \treftable_record_from_ref(&rec, &ref);\n+ \treturn tab->ops->seek_record(tab->table_arg, it, &rec);\n+ }\n+@@ reftable/reftable.c: void reftable_table_from_reader(struct reftable_table *tab,\n+ int reftable_table_read_ref(struct reftable_table *tab, const char *name,\n+ \t\t\t struct reftable_ref_record *ref)\n+ {\n+-\tstruct reftable_iterator it = { 0 };\n++\tstruct reftable_iterator it = { NULL };\n+ \tint err = reftable_table_seek_ref(tab, &it, name);\n+ \tif (err)\n+ \t\tgoto done;\n+\n## reftable/stack.c (new) ##\n@@\n+/*\n@@ reftable/stack.c (new)\n+#include \"reftable.h\"\n+#include \"writer.h\"\n+\n++\t\t\t int (*write_table)(struct reftable_writer *wr,\n++\t\t\t\t\t void *arg),\n++\t\t\t void *arg);\n++static int stack_write_compact(struct reftable_stack *st,\n++\t\t\t struct reftable_writer *wr, int first, int last,\n++\t\t\t struct reftable_log_expiry_config *config);\n++\t\t\t\tconst char *new_tab_name);\n++\t\t\t\t\t int reuse_open);\n++\n+int reftable_new_stack(struct reftable_stack **dest, const char *dir,\n+\t\t struct reftable_write_options config)\n+{\n@@ reftable/stack.c (new)\n+\t\t}\n+\n+\t\tif (rd == NULL) {\n-+\t\t\tstruct reftable_block_source src = { 0 };\n++\t\t\tstruct reftable_block_source src = { NULL };\n+\t\t\tstruct strbuf table_path = STRBUF_INIT;\n@@ reftable/stack.c (new)\n+\treturn udiff;\n+}\n+\n-+int reftable_stack_reload_maybe_reuse(struct reftable_stack *st, int reuse_open)\n++\t\t\t\t\t int reuse_open)\n+{\n+\tstruct timeval deadline = { 0 };\n+\tint err = gettimeofday(&deadline, NULL);\n@@ reftable/stack.c (new)\n+\treturn err;\n+}\n+\n+{\n+\tint i = 0;\n+\tstruct strbuf nm = STRBUF_INIT;\n@@ reftable/stack.c (new)\n+\treturn err;\n+}\n+\n-+\t\t int (*write_table)(struct reftable_writer *wr, void *arg),\n-+\t\t void *arg)\n++\t\t\t int (*write_table)(struct reftable_writer *wr,\n++\t\t\t\t\t void *arg),\n++\t\t\t void *arg)\n+{\n@@ reftable/stack.c (new)\n+\treturn err;\n+}\n+\n-+int stack_write_compact(struct reftable_stack *st, struct reftable_writer *wr,\n-+\t\t\tint first, int last,\n-+\t\t\tstruct reftable_log_expiry_config *config)\n++static int stack_write_compact(struct reftable_stack *st,\n++\t\t\t struct reftable_writer *wr, int first, int last,\n++\t\t\t struct reftable_log_expiry_config *config)\n+{\n+\tint subtabs_len = last - first + 1;\n+\tstruct reftable_table *subtabs = reftable_calloc(\n+\t\tsizeof(struct reftable_table) * (last - first + 1));\n+\tstruct reftable_merged_table *mt = NULL;\n+\tint err = 0;\n-+\tstruct reftable_iterator it = { 0 };\n-+\tstruct reftable_ref_record ref = { 0 };\n-+\tstruct reftable_log_record log = { 0 };\n++\tstruct reftable_iterator it = { NULL };\n++\tstruct reftable_ref_record ref = { NULL };\n++\tstruct reftable_log_record log = { NULL };\n+\n+\tuint64_t entries = 0;\n+\n@@ reftable/stack.c (new)\n+int reftable_stack_read_log(struct reftable_stack *st, const char *refname,\n+\t\t\t struct reftable_log_record *log)\n+{\n-+\tstruct reftable_iterator it = { 0 };\n++\tstruct reftable_iterator it = { NULL };\n+\tstruct reftable_merged_table *mt = reftable_stack_merged_table(st);\n+\tint err = reftable_merged_table_seek_log(mt, &it, refname);\n+\tif (err)\n@@ reftable/stack.c (new)\n+\treturn err;\n+}\n+\n-+int stack_check_addition(struct reftable_stack *st, const char *new_tab_name)\n++\t\t\t\tconst char *new_tab_name)\n+{\n+\tint err = 0;\n-+\tstruct reftable_block_source src = { 0 };\n++\tstruct reftable_block_source src = { NULL };\n+\tstruct reftable_reader *rd = NULL;\n+\tstruct reftable_table tab = { NULL };\n+\tstruct reftable_ref_record *refs = NULL;\n@@ reftable/stack.c (new)\n+\t\tgoto done;\n+\n+\twhile (1) {\n-+\t\tstruct reftable_ref_record ref = { 0 };\n++\t\tstruct reftable_ref_record ref = { NULL };\n+\t\terr = reftable_iterator_next_ref(&it, &ref);\n+\t\tif (err > 0) {\n+\t\t\tbreak;\n@@ reftable/stack.h (new)\n+};\n+\n+int read_lines(const char *filename, char ***lines);\n-+\t\t int (*write_table)(struct reftable_writer *wr, void *arg),\n-+\t\t void *arg);\n-+int stack_write_compact(struct reftable_stack *st, struct reftable_writer *wr,\n-+\t\t\tint first, int last,\n-+\t\t\tstruct reftable_log_expiry_config *config);\n-+int fastlog2(uint64_t sz);\n-+int stack_check_addition(struct reftable_stack *st, const char *new_tab_name);\n-+\t\t\t\t int reuse_open);\n+\n+struct segment {\n+\tint start, end;\n@@ reftable/stack.h (new)\n+\tuint64_t bytes;\n+};\n+\n++int fastlog2(uint64_t sz);\n+struct segment *sizes_to_segments(int *seglen, uint64_t *sizes, int n);\n+struct segment suggest_compaction_segment(uint64_t *sizes, int n);\n+\n@@ reftable/stack_test.c (new)\n+\t\t.update_index = 1,\n+\t\t.target = \"master\",\n+\t};\n-+\tstruct reftable_ref_record dest = { 0 };\n++\tstruct reftable_ref_record dest = { NULL };\n+\n+\tassert(mkdtemp(dir));\n+\n@@ reftable/stack_test.c (new)\n+\t\t.update_index = 1,\n+\t\t.target = \"master\",\n+\t};\n-+\tstruct reftable_ref_record dest = { 0 };\n++\tstruct reftable_ref_record dest = { NULL };\n+\n+\tassert(mkdtemp(dir));\n+\n@@ reftable/stack_test.c (new)\n+\t};\n+\tstruct reftable_stack *st = NULL;\n+\tchar dir = \"/tmp/stack_test.XXXXXX\";\n-+\tstruct reftable_ref_record refs = { { 0 } };\n-+\tstruct reftable_log_record logs = { { 0 } };\n++\tstruct reftable_ref_record refs = { { NULL } };\n++\tstruct reftable_log_record logs = { { NULL } };\n+\tint N = ARRAY_SIZE(refs);\n+\n+\tassert(mkdtemp(dir));\n@@ reftable/stack_test.c (new)\n+\tassert_err(err);\n+\n+\tfor (i = 0; i < N; i++) {\n-+\t\tstruct reftable_ref_record dest = { 0 };\n++\t\tstruct reftable_ref_record dest = { NULL };\n++\n+\t\tint err = reftable_stack_read_ref(st, refs[i].refname, &dest);\n+\t\tassert_err(err);\n+\t\tassert(reftable_ref_record_equal(&dest, refs + i, SHA1_SIZE));\n@@ reftable/stack_test.c (new)\n+\t}\n+\n+\tfor (i = 0; i < N; i++) {\n-+\t\tstruct reftable_log_record dest = { 0 };\n++\t\tstruct reftable_log_record dest = { NULL };\n+\t\tint err = reftable_stack_read_log(st, refs[i].refname, &dest);\n+\t\tassert_err(err);\n+\t\tassert(reftable_log_record_equal(&dest, logs + i, SHA1_SIZE));\n@@ reftable/stack_test.c (new)\n+\tstruct reftable_write_options cfg = { 0 };\n+\tstruct reftable_stack *st = NULL;\n+\tint err;\n-+\tstruct reftable_ref_record refs = { { 0 } };\n-+\tstruct reftable_log_record logs = { { 0 } };\n++\tstruct reftable_ref_record refs = { { NULL } };\n++\tstruct reftable_log_record logs = { { NULL } };\n+\tint N = ARRAY_SIZE(refs);\n-+\tstruct reftable_ref_record dest = { 0 };\n-+\tstruct reftable_log_record log_dest = { 0 };\n++\tstruct reftable_ref_record dest = { NULL };\n++\tstruct reftable_log_record log_dest = { NULL };\n+\n+\tassert(mkdtemp(dir));\n+\n@@ reftable/stack_test.c (new)\n+\tstruct reftable_stack *st32 = NULL;\n+\tstruct reftable_write_options cfg_default = { 0 };\n+\tstruct reftable_stack *st_default = NULL;\n-+\tstruct reftable_ref_record dest = { 0 };\n++\tstruct reftable_ref_record dest = { NULL };\n+\n+\tassert(mkdtemp(dir));\n+\terr = reftable_new_stack(&st, dir, cfg);\n@@ reftable/stack_test.c (new)\n+\tchar dir = \"/tmp/stack.test_reflog_expire.XXXXXX\";\n+\tstruct reftable_write_options cfg = { 0 };\n+\tstruct reftable_stack *st = NULL;\n-+\tstruct reftable_log_record logs = { { 0 } };\n++\tstruct reftable_log_record logs = { { NULL } };\n+\tint N = ARRAY_SIZE(logs) - 1;\n+\tint i = 0;\n+\tint err;\n+\tstruct reftable_log_expiry_config expiry = {\n+\t\t.time = 10,\n+\t};\n-+\tstruct reftable_log_record log = { 0 };\n++\tstruct reftable_log_record log = { NULL };\n+\n+\tassert(mkdtemp(dir));\n+\n13: b8729fee9e ! 13: c535f838d6 reftable: \"test-tool dump-reftable\" command.\n@@ Makefile: REFTABLE_OBJS += reftable/writer.o\nREFTABLE_TEST_OBJS += reftable/refname_test.o\nREFTABLE_TEST_OBJS += reftable/reftable_test.o\n\n+ ## reftable/iter.c ##\n+@@ reftable/iter.c: void reftable_iterator_destroy(struct reftable_iterator *it)\n+ int reftable_iterator_next_ref(struct reftable_iterator *it,\n+ \t\t\t struct reftable_ref_record *ref)\n+ {\n+-\tstruct reftable_record rec = { 0 };\n++\tstruct reftable_record rec = { NULL };\n+ \treftable_record_from_ref(&rec, ref);\n+ \treturn iterator_next(it, &rec);\n+ }\n+@@ reftable/iter.c: int reftable_iterator_next_ref(struct reftable_iterator *it,\n+ int reftable_iterator_next_log(struct reftable_iterator *it,\n+ \t\t\t struct reftable_log_record *log)\n+ {\n+-\tstruct reftable_record rec = { 0 };\n++\tstruct reftable_record rec = { NULL };\n+ \treftable_record_from_log(&rec, log);\n+ \treturn iterator_next(it, &rec);\n+ }\n+@@ reftable/iter.c: static int filtering_ref_iterator_next(void *iter_arg,\n+ \t\t}\n+\n+ \t\tif (fri->double_check) {\n+-\t\t\tstruct reftable_iterator it = { 0 };\n++\t\t\tstruct reftable_iterator it = { NULL };\n+\n+ \t\t\terr = reftable_table_seek_ref(&fri->tab, &it,\n+ \t\t\t\t\t\t ref->refname);\n+\n+ \t\tconst char *name)\n+ {\n+-\tstruct reftable_block footer = { 0 };\n+-\tstruct reftable_block header = { 0 };\n++\tstruct reftable_block footer = { NULL };\n++\tstruct reftable_block header = { NULL };\n+ \tint err = 0;\n+\n+ {\n+ \tint32_t guess_block_size = r->block_size ? r->block_size :\n+ \t\t\t\t\t\t\t DEFAULT_BLOCK_SIZE;\n+-\tstruct reftable_block block = { 0 };\n++\tstruct reftable_block block = { NULL };\n+ \tuint8_t block_typ = 0;\n+ \tint err = 0;\n+ \t\t\t struct reftable_record *rec)\n+ {\n+ \tstruct reftable_index_record want_index = { .last_key = STRBUF_INIT };\n+-\tstruct reftable_record want_index_rec = { 0 };\n++\tstruct reftable_record want_index_rec = { NULL };\n+ \tstruct reftable_index_record index_result = { .last_key = STRBUF_INIT };\n+-\tstruct reftable_record index_result_rec = { 0 };\n++\tstruct reftable_record index_result_rec = { NULL };\n+ \tstruct table_iter index_iter = TABLE_ITER_INIT;\n+ \tstruct table_iter next = TABLE_ITER_INIT;\n+ \tint err = 0;\n+ \tstruct reftable_ref_record ref = {\n+ \t\t.refname = (char *)name,\n+ \t};\n+-\tstruct reftable_record rec = { 0 };\n++\tstruct reftable_record rec = { NULL };\n+ \treftable_record_from_ref(&rec, &ref);\n+ }\n+ \t\t.refname = (char *)name,\n+ \t\t.update_index = update_index,\n+ \t};\n+-\tstruct reftable_record rec = { 0 };\n++\tstruct reftable_record rec = { NULL };\n+ \treftable_record_from_log(&rec, &log);\n+ }\n+ \t\t.hash_prefix = oid,\n+ \t\t.hash_prefix_len = r->object_id_len,\n+ \t};\n+-\tstruct reftable_record want_rec = { 0 };\n+-\tstruct reftable_iterator oit = { 0 };\n+-\tstruct reftable_obj_record got = { 0 };\n+-\tstruct reftable_record got_rec = { 0 };\n++\tstruct reftable_record want_rec = { NULL };\n++\tstruct reftable_iterator oit = { NULL };\n++\tstruct reftable_obj_record got = { NULL };\n++\tstruct reftable_record got_rec = { NULL };\n+ \tint err = 0;\n+ \tstruct indexed_table_ref_iter *itr = NULL;\n+\n+\n## t/helper/test-reftable.c ##\n@@ t/helper/test-reftable.c: int cmd__reftable(int argc, const char **argv)\ntree_test_main(argc, argv);\n\n--\n\n• ```* [PATCH v2 01/13] reftable: add LICENSE\n2020-10-01 16:10 ` [PATCH v2 00/13] reftable library Han-Wen Nienhuys via GitGitGadget\n@ 2020-10-01 16:10 ` Han-Wen Nienhuys via GitGitGadget\n2020-10-02 3:18 ` Jonathan Nieder\n2020-10-01 16:10 ` [PATCH v2 02/13] reftable: define the public API Han-Wen Nienhuys via GitGitGadget\n` (12 subsequent siblings)\nFrom: Han-Wen Nienhuys via GitGitGadget @ 2020-10-01 16:10 UTC (permalink / raw)\nTo: git; +Cc: Han-Wen Nienhuys, Jeff King, Han-Wen Nienhuys, Han-Wen Nienhuys\n\n---\n1 file changed, 31 insertions(+)\n\nnew file mode 100644\nindex 0000000000..402e0f9356\n--- /dev/null\n@@ -0,0 +1,31 @@\n+\n+\n+Redistribution and use in source and binary forms, with or without\n+modification, are permitted provided that the following conditions are\n+met:\n+\n+* Redistributions of source code must retain the above copyright notice,\n+this list of conditions and the following disclaimer.\n+\n+* Redistributions in binary form must reproduce the above copyright\n+notice, this list of conditions and the following disclaimer in the\n+documentation and/or other materials provided with the distribution.\n+\n+* Neither the name of Google LLC nor the names of its contributors may\n+be used to endorse or promote products derived from this software\n+without specific prior written permission.\n+\n+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n+\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n--\n\n• ```* Re: [PATCH v2 01/13] reftable: add LICENSE\n@ 2020-10-02 3:18 ` Jonathan Nieder\n0 siblings, 0 replies; 251+ messages in thread\nFrom: Jonathan Nieder @ 2020-10-02 3:18 UTC (permalink / raw)\nCc: git, Han-Wen Nienhuys, Jeff King, Han-Wen Nienhuys\n\nHi,\n\nHan-Wen Nienhuys wrote:\n\nThis line presumably doesn't want to be part of permanent history. :)\n\nInstead, it can say a little about rationale. For example, does this\nmake the code easier for other projects like libgit2 to share?\n\n> ---\n> 1 file changed, 31 insertions(+)\n\nShould there be a reftable/README as well?\n\n[...]\n> --- /dev/null\n> @@ -0,0 +1,31 @@\n> +\n\nnit: Google seems to prefer a slightly more spartan form of this\n\nNits aside, except for the TODO line, this patch looks reasonable to\nme.\n\nThanks,\nJonathan\n\n• ```* [PATCH v2 02/13] reftable: define the public API\n2020-10-01 16:10 ` [PATCH v2 00/13] reftable library Han-Wen Nienhuys via GitGitGadget\n@ 2020-10-01 16:10 ` Han-Wen Nienhuys via GitGitGadget\n2020-10-02 3:58 ` Jonathan Nieder\n2020-10-08 1:41 ` Jonathan Tan\n2020-10-01 16:10 ` [PATCH v2 03/13] vcxproj: adjust for the reftable changes Johannes Schindelin via GitGitGadget\n` (11 subsequent siblings)\n13 siblings, 2 replies; 251+ messages in thread\nFrom: Han-Wen Nienhuys via GitGitGadget @ 2020-10-01 16:10 UTC (permalink / raw)\nTo: git; +Cc: Han-Wen Nienhuys, Jeff King, Han-Wen Nienhuys, Han-Wen Nienhuys\n\n---\nreftable/reftable.h | 585 ++++++++++++++++++++++++++++++++++++++++++++\n1 file changed, 585 insertions(+)\ncreate mode 100644 reftable/reftable.h\n\ndiff --git a/reftable/reftable.h b/reftable/reftable.h\nnew file mode 100644\nindex 0000000000..5f8ebf5540\n--- /dev/null\n+++ b/reftable/reftable.h\n@@ -0,0 +1,585 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#ifndef REFTABLE_H\n+#define REFTABLE_H\n+\n+#include <stdint.h>\n+#include <stddef.h>\n+\n+void reftable_set_alloc(void *(*malloc)(size_t),\n+\t\t\tvoid *(*realloc)(void *, size_t), void (*free)(void *));\n+\n+/****************************************************************\n+ Basic data types\n+\n+ Reftables store the state of each ref in struct reftable_ref_record, and they\n+ store a sequence of reflog updates in struct reftable_log_record.\n+ ****************************************************************/\n+\n+/* reftable_ref_record holds a ref database entry target_value */\n+struct reftable_ref_record {\n+\tchar *refname; /* Name of the ref, malloced. */\n+\tuint64_t update_index; /* Logical timestamp at which this value is\n+\t\t\t\t written */\n+\tuint8_t *value; /* SHA1, or NULL. malloced. */\n+\tuint8_t *target_value; /* peeled annotated tag, or NULL. malloced. */\n+\tchar *target; /* symref, or NULL. malloced. */\n+};\n+\n+/* returns whether 'ref' represents a deletion */\n+int reftable_ref_record_is_deletion(const struct reftable_ref_record *ref);\n+\n+/* prints a reftable_ref_record onto stdout */\n+void reftable_ref_record_print(struct reftable_ref_record *ref,\n+\t\t\t uint32_t hash_id);\n+\n+/* frees and nulls all pointer values. */\n+void reftable_ref_record_clear(struct reftable_ref_record *ref);\n+\n+/* returns whether two reftable_ref_records are the same */\n+int reftable_ref_record_equal(struct reftable_ref_record *a,\n+\t\t\t struct reftable_ref_record *b, int hash_size);\n+\n+/* reftable_log_record holds a reflog entry */\n+struct reftable_log_record {\n+\tchar *refname;\n+\tuint64_t update_index; /* logical timestamp of a transactional update.\n+\t\t\t\t*/\n+\tuint8_t *new_hash;\n+\tuint8_t *old_hash;\n+\tchar *name;\n+\tchar *email;\n+\tuint64_t time;\n+\tint16_t tz_offset;\n+\tchar *message;\n+};\n+\n+/* returns whether 'ref' represents the deletion of a log record. */\n+int reftable_log_record_is_deletion(const struct reftable_log_record *log);\n+\n+/* frees and nulls all pointer values. */\n+void reftable_log_record_clear(struct reftable_log_record *log);\n+\n+/* returns whether two records are equal. */\n+int reftable_log_record_equal(struct reftable_log_record *a,\n+\t\t\t struct reftable_log_record *b, int hash_size);\n+\n+/* dumps a reftable_log_record on stdout, for debugging/testing. */\n+void reftable_log_record_print(struct reftable_log_record *log,\n+\t\t\t uint32_t hash_id);\n+\n+/****************************************************************\n+ Error handling\n+\n+ Error are signaled with negative integer return values. 0 means success.\n+ ****************************************************************/\n+\n+/* different types of errors */\n+enum reftable_error {\n+\t/* Unexpected file system behavior */\n+\tREFTABLE_IO_ERROR = -2,\n+\n+\t/* Format inconsistency on reading data\n+\t */\n+\tREFTABLE_FORMAT_ERROR = -3,\n+\n+\t/* File does not exist. Returned from block_source_from_file(), because\n+\t it needs special handling in stack.\n+\t*/\n+\tREFTABLE_NOT_EXIST_ERROR = -4,\n+\n+\t/* Trying to write out-of-date data. */\n+\tREFTABLE_LOCK_ERROR = -5,\n+\n+\t/* Misuse of the API:\n+\t - on writing a record with NULL refname.\n+\t - on writing a reftable_ref_record outside the table limits\n+\t - on writing a ref or log record before the stack's next_update_index\n+\t - on writing a log record with multiline message with\n+\t exact_log_message unset\n+\t - on reading a reftable_ref_record from log iterator, or vice versa.\n+\t*/\n+\tREFTABLE_API_ERROR = -6,\n+\n+\t/* Decompression error */\n+\tREFTABLE_ZLIB_ERROR = -7,\n+\n+\t/* Wrote a table without blocks. */\n+\tREFTABLE_EMPTY_TABLE_ERROR = -8,\n+\n+\t/* Dir/file conflict. */\n+\tREFTABLE_NAME_CONFLICT = -9,\n+\n+\t/* Illegal ref name. */\n+\tREFTABLE_REFNAME_ERROR = -10,\n+};\n+\n+/* convert the numeric error code to a string. The string should not be\n+ * deallocated. */\n+const char *reftable_error_str(int err);\n+\n+/*\n+ * Convert the numeric error code to an equivalent errno code.\n+ */\n+int reftable_error_to_errno(int err);\n+\n+/****************************************************************\n+ Writing\n+\n+ Writing single reftables\n+ ****************************************************************/\n+\n+/* reftable_write_options sets options for writing a single reftable. */\n+struct reftable_write_options {\n+\t/* boolean: do not pad out blocks to block size. */\n+\n+\t/* the blocksize. Should be less than 2^24. */\n+\tuint32_t block_size;\n+\n+\t/* boolean: do not generate a SHA1 => ref index. */\n+\tint skip_index_objects;\n+\n+\t/* how often to write complete keys in each block. */\n+\tint restart_interval;\n+\n+\t/* 4-byte identifier (\"sha1\", \"s256\") of the hash.\n+\t * Defaults to SHA1 if unset\n+\t */\n+\tuint32_t hash_id;\n+\n+\t/* boolean: do not check ref names for validity or dir/file conflicts.\n+\t */\n+\tint skip_name_check;\n+\n+\t/* boolean: copy log messages exactly. If unset, check that the message\n+\t * is a single line, and add '\\n' if missing.\n+\t */\n+\tint exact_log_message;\n+};\n+\n+/* reftable_block_stats holds statistics for a single block type */\n+struct reftable_block_stats {\n+\t/* total number of entries written */\n+\tint entries;\n+\t/* total number of key restarts */\n+\tint restarts;\n+\t/* total number of blocks */\n+\tint blocks;\n+\t/* total number of index blocks */\n+\tint index_blocks;\n+\t/* depth of the index */\n+\tint max_index_level;\n+\n+\t/* offset of the first block for this type */\n+\tuint64_t offset;\n+\t/* offset of the top level index block for this type, or 0 if not\n+\t * present */\n+\tuint64_t index_offset;\n+};\n+\n+/* stats holds overall statistics for a single reftable */\n+struct reftable_stats {\n+\t/* total number of blocks written. */\n+\tint blocks;\n+\t/* stats for ref data */\n+\tstruct reftable_block_stats ref_stats;\n+\t/* stats for the SHA1 to ref map. */\n+\tstruct reftable_block_stats obj_stats;\n+\t/* stats for index blocks */\n+\tstruct reftable_block_stats idx_stats;\n+\t/* stats for log blocks */\n+\tstruct reftable_block_stats log_stats;\n+\n+\t/* disambiguation length of shortened object IDs. */\n+\tint object_id_len;\n+};\n+\n+/* reftable_new_writer creates a new writer */\n+struct reftable_writer *\n+reftable_new_writer(int (*writer_func)(void *, const void *, size_t),\n+\t\t void *writer_arg, struct reftable_write_options *opts);\n+\n+/* write to a file descriptor. fdp should be an int* pointing to the fd. */\n+int reftable_fd_write(void *fdp, const void *data, size_t size);\n+\n+/* Set the range of update indices for the records we will add. When\n+ writing a table into a stack, the min should be at least\n+ reftable_stack_next_update_index(), or REFTABLE_API_ERROR is returned.\n+\n+ For transactional updates, typically min==max. When converting an existing\n+ ref database into a single reftable, this would be a range of update-index\n+ timestamps.\n+ */\n+void reftable_writer_set_limits(struct reftable_writer *w, uint64_t min,\n+\t\t\t\tuint64_t max);\n+\n+/* adds a reftable_ref_record. Must be called in ascending\n+ order. The update_index must be within the limits set by\n+ reftable_writer_set_limits(), or REFTABLE_API_ERROR is returned.\n+\n+ It is an error to write a ref record after a log record.\n+ */\n+\t\t\t struct reftable_ref_record *ref);\n+\n+/* Convenience function to add multiple refs. Will sort the refs by\n+\t\t\t struct reftable_ref_record *refs, int n);\n+\n+/* adds a reftable_log_record. Must be called in ascending order (with more\n+ recent log entries first.)\n+ */\n+\t\t\t struct reftable_log_record *log);\n+\n+/* Convenience function to add multiple logs. Will sort the records by\n+\t\t\t struct reftable_log_record *logs, int n);\n+\n+/* reftable_writer_close finalizes the reftable. The writer is retained so\n+ * statistics can be inspected. */\n+int reftable_writer_close(struct reftable_writer *w);\n+\n+/* writer_stats returns the statistics on the reftable being written.\n+\n+ This struct becomes invalid when the writer is freed.\n+ */\n+const struct reftable_stats *writer_stats(struct reftable_writer *w);\n+\n+/* reftable_writer_free deallocates memory for the writer */\n+void reftable_writer_free(struct reftable_writer *w);\n+\n+/****************************************************************\n+ * ITERATING\n+ ****************************************************************/\n+\n+/* iterator is the generic interface for walking over data stored in a\n+ reftable. It is generally passed around by value.\n+*/\n+struct reftable_iterator {\n+\tstruct reftable_iterator_vtable *ops;\n+\tvoid *iter_arg;\n+};\n+\n+/* reads the next reftable_ref_record. Returns < 0 for error, 0 for OK and > 0:\n+ end of iteration.\n+*/\n+int reftable_iterator_next_ref(struct reftable_iterator *it,\n+\t\t\t struct reftable_ref_record *ref);\n+\n+/* reads the next reftable_log_record. Returns < 0 for error, 0 for OK and > 0:\n+ end of iteration.\n+*/\n+int reftable_iterator_next_log(struct reftable_iterator *it,\n+\t\t\t struct reftable_log_record *log);\n+\n+/* releases resources associated with an iterator. */\n+void reftable_iterator_destroy(struct reftable_iterator *it);\n+\n+/****************************************************************\n+\n+ The follow routines are for reading single files. For an application-level\n+ interface, skip ahead to struct reftable_merged_table and struct\n+ reftable_stack.\n+ ****************************************************************/\n+\n+/* block_source is a generic wrapper for a seekable readable file.\n+ It is generally passed around by value.\n+ */\n+struct reftable_block_source {\n+\tstruct reftable_block_source_vtable *ops;\n+\tvoid *arg;\n+};\n+\n+/* a contiguous segment of bytes. It keeps track of its generating block_source\n+ so it can return itself into the pool.\n+*/\n+struct reftable_block {\n+\tuint8_t *data;\n+\tint len;\n+\tstruct reftable_block_source source;\n+};\n+\n+/* block_source_vtable are the operations that make up block_source */\n+struct reftable_block_source_vtable {\n+\t/* returns the size of a block source */\n+\tuint64_t (*size)(void *source);\n+\n+\t/* reads a segment from the block source. It is an error to read\n+\t beyond the end of the block */\n+\tint (*read_block)(void *source, struct reftable_block *dest,\n+\t\t\t uint64_t off, uint32_t size);\n+\t/* mark the block as read; may return the data back to malloc */\n+\tvoid (*return_block)(void *source, struct reftable_block *blockp);\n+\n+\t/* release all resources associated with the block source */\n+\tvoid (*close)(void *source);\n+};\n+\n+/* opens a file on the file system as a block_source */\n+int reftable_block_source_from_file(struct reftable_block_source *block_src,\n+\t\t\t\t const char *name);\n+\n+/* The reader struct is a handle to an open reftable file. */\n+\n+ * code and sets pp. The name is used for creating a stack. Typically, it is the\n+ * basename of the file. The block source `src` is owned by the reader, and is\n+ * closed on calling reftable_reader_destroy().\n+ */\n+\t\t\tstruct reftable_block_source *src, const char *name);\n+\n+/* reftable_reader_seek_ref returns an iterator where 'name' would be inserted\n+ in the table. To seek to the start of the table, use name = \"\".\n+\n+ example:\n+\n+ struct reftable_reader *r = NULL;\n+ int err = reftable_new_reader(&r, &src, \"filename\");\n+ if (err < 0) { ... }\n+ struct reftable_iterator it = {0};\n+ if (err < 0) { ... }\n+ struct reftable_ref_record ref = {0};\n+ while (1) {\n+ err = reftable_iterator_next_ref(&it, &ref);\n+ if (err > 0) {\n+ break;\n+ }\n+ if (err < 0) {\n+ ..error handling..\n+ }\n+ ..found..\n+ }\n+ reftable_iterator_destroy(&it);\n+ reftable_ref_record_clear(&ref);\n+ */\n+\t\t\t struct reftable_iterator *it, const char *name);\n+\n+/* returns the hash ID used in this table. */\n+\n+/* seek to logs for the given name, older than update_index. To seek to the\n+ start of the table, use name = \"\".\n+ */\n+\t\t\t\tstruct reftable_iterator *it, const char *name,\n+\t\t\t\tuint64_t update_index);\n+\n+/* seek to newest log entry for given name. */\n+\t\t\t struct reftable_iterator *it, const char *name);\n+\n+/* closes and deallocates a reader. */\n+\n+/* return an iterator for the refs pointing to `oid`. */\n+\t\t\t struct reftable_iterator *it, uint8_t *oid);\n+\n+/* return the max_update_index for a table */\n+\n+/* return the min_update_index for a table */\n+\n+/****************************************************************\n+ Merged tables\n+\n+ A ref database kept in a sequence of table files. The merged_table presents a\n+ unified view to reading (seeking, iterating) a sequence of immutable tables.\n+ ****************************************************************/\n+\n+/* A merged table is implements seeking/iterating over a stack of tables. */\n+struct reftable_merged_table;\n+\n+/* A generic reftable; see below. */\n+struct reftable_table;\n+\n+/* reftable_new_merged_table creates a new merged table. It takes ownership of\n+ the stack array.\n+*/\n+int reftable_new_merged_table(struct reftable_merged_table **dest,\n+\t\t\t struct reftable_table *stack, int n,\n+\t\t\t uint32_t hash_id);\n+\n+/* returns an iterator positioned just before 'name' */\n+int reftable_merged_table_seek_ref(struct reftable_merged_table *mt,\n+\t\t\t\t struct reftable_iterator *it,\n+\t\t\t\t const char *name);\n+\n+/* returns an iterator for log entry, at given update_index */\n+int reftable_merged_table_seek_log_at(struct reftable_merged_table *mt,\n+\t\t\t\t struct reftable_iterator *it,\n+\t\t\t\t const char *name, uint64_t update_index);\n+\n+/* like reftable_merged_table_seek_log_at but look for the newest entry. */\n+int reftable_merged_table_seek_log(struct reftable_merged_table *mt,\n+\t\t\t\t struct reftable_iterator *it,\n+\t\t\t\t const char *name);\n+\n+/* returns the max update_index covered by this merged table. */\n+uint64_t\n+reftable_merged_table_max_update_index(struct reftable_merged_table *mt);\n+\n+/* returns the min update_index covered by this merged table. */\n+uint64_t\n+reftable_merged_table_min_update_index(struct reftable_merged_table *mt);\n+\n+/* releases memory for the merged_table */\n+void reftable_merged_table_free(struct reftable_merged_table *m);\n+\n+/* return the hash ID of the merged table. */\n+uint32_t reftable_merged_table_hash_id(struct reftable_merged_table *m);\n+\n+/****************************************************************\n+ Generic tables\n+\n+ A unified API for reading tables, either merged tables, or single readers.\n+ ****************************************************************/\n+\n+struct reftable_table {\n+\tstruct reftable_table_vtable *ops;\n+\tvoid *table_arg;\n+};\n+\n+int reftable_table_seek_ref(struct reftable_table *tab,\n+\t\t\t struct reftable_iterator *it, const char *name);\n+\n+\n+/* returns the hash ID from a generic reftable_table */\n+uint32_t reftable_table_hash_id(struct reftable_table *tab);\n+\n+/* create a generic table from reftable_merged_table */\n+void reftable_table_from_merged_table(struct reftable_table *tab,\n+\t\t\t\t struct reftable_merged_table *table);\n+\n+/* returns the max update_index covered by this table. */\n+uint64_t reftable_table_max_update_index(struct reftable_table *tab);\n+\n+/* returns the min update_index covered by this table. */\n+uint64_t reftable_table_min_update_index(struct reftable_table *tab);\n+\n+/* convenience function to read a single ref. Returns < 0 for error, 0\n+int reftable_table_read_ref(struct reftable_table *tab, const char *name,\n+\t\t\t struct reftable_ref_record *ref);\n+\n+/****************************************************************\n+ Mutable ref database\n+\n+ The stack presents an interface to a mutable sequence of reftables.\n+ ****************************************************************/\n+\n+/* a stack is a stack of reftables, which can be mutated by pushing a table to\n+ * the top of the stack */\n+struct reftable_stack;\n+\n+/* open a new reftable stack. The tables along with the table list will be\n+ stored in 'dir'. Typically, this should be .git/reftables.\n+*/\n+int reftable_new_stack(struct reftable_stack **dest, const char *dir,\n+\t\t struct reftable_write_options config);\n+\n+/* returns the update_index at which a next table should be written. */\n+uint64_t reftable_stack_next_update_index(struct reftable_stack *st);\n+\n+/* holds a transaction to add tables at the top of a stack. */\n+\n+/*\n+ returns a new transaction to add reftables to the given stack. As a side\n+ effect, the ref database is locked.\n+*/\n+\t\t\t\tstruct reftable_stack *st);\n+\n+/* Adds a reftable to transaction. */\n+\t\t\t int (*write_table)(struct reftable_writer *wr,\n+\t\t\t\t\t void *arg),\n+\t\t\t void *arg);\n+\n+/* Commits the transaction, releasing the lock. */\n+\n+/* Release all non-committed data from the transaction, and deallocate the\n+ transaction. Releases the lock if held. */\n+\n+/* add a new table to the stack. The write_table function must call\n+ reftable_writer_set_limits, add refs and return an error value. */\n+\t\t int (*write_table)(struct reftable_writer *wr,\n+\t\t\t\t\t void *write_arg),\n+\t\t void *write_arg);\n+\n+/* returns the merged_table for seeking. This table is valid until the\n+ next write or reload, and should not be closed or deleted.\n+*/\n+struct reftable_merged_table *\n+reftable_stack_merged_table(struct reftable_stack *st);\n+\n+/* frees all resources associated with the stack. */\n+void reftable_stack_destroy(struct reftable_stack *st);\n+\n+/* Reloads the stack if necessary. This is very cheap to run if the stack was up\n+ * to date */\n+\n+/* Policy for expiring reflog entries. */\n+struct reftable_log_expiry_config {\n+\t/* Drop entries older than this timestamp */\n+\tuint64_t time;\n+\n+\t/* Drop older entries */\n+\tuint64_t min_update_index;\n+};\n+\n+/* compacts all reftables into a giant table. Expire reflog entries if config is\n+ * non-NULL */\n+int reftable_stack_compact_all(struct reftable_stack *st,\n+\t\t\t struct reftable_log_expiry_config *config);\n+\n+/* heuristically compact unbalanced table stack. */\n+int reftable_stack_auto_compact(struct reftable_stack *st);\n+\n+/* convenience function to read a single ref. Returns < 0 for error, 0\n+int reftable_stack_read_ref(struct reftable_stack *st, const char *refname,\n+\t\t\t struct reftable_ref_record *ref);\n+\n+/* convenience function to read a single log. Returns < 0 for error, 0\n+int reftable_stack_read_log(struct reftable_stack *st, const char *refname,\n+\t\t\t struct reftable_log_record *log);\n+\n+/* statistics on past compactions. */\n+struct reftable_compaction_stats {\n+\tuint64_t bytes; /* total number of bytes written */\n+\tuint64_t entries_written; /* total number of entries written, including\n+\t\t\t\t failures. */\n+\tint attempts; /* how often we tried to compact */\n+\tint failures; /* failures happen on concurrent updates */\n+};\n+\n+/* return statistics for compaction up till now. */\n+struct reftable_compaction_stats *\n+reftable_stack_compaction_stats(struct reftable_stack *st);\n+\n+#endif\n--\n\n• ```* Re: [PATCH v2 02/13] reftable: define the public API\n2020-10-01 16:10 ` [PATCH v2 02/13] reftable: define the public API Han-Wen Nienhuys via GitGitGadget\n@ 2020-10-02 3:58 ` Jonathan Nieder\n2020-10-09 21:13 ` Emily Shaffer\n2020-10-10 13:43 ` Han-Wen Nienhuys\n2020-10-08 1:41 ` Jonathan Tan\n1 sibling, 2 replies; 251+ messages in thread\nFrom: Jonathan Nieder @ 2020-10-02 3:58 UTC (permalink / raw)\nCc: git, Han-Wen Nienhuys, Jeff King, Han-Wen Nienhuys\n\nHi,\n\nHan-Wen Nienhuys wrote:\n\n> reftable/reftable.h | 585 ++++++++++++++++++++++++++++++++++++++++++++\n> 1 file changed, 585 insertions(+)\n> create mode 100644 reftable/reftable.h\n\nmatch the usual practice. Can we add declarations in the same patch\nas the functions being declared instead?\n\nWe could still introduce the header early in its own patch if we want,\nbut it would be a skeleton of a header that gets filled out by later\npatches.\n\n[...]\n> --- /dev/null\n> +++ b/reftable/reftable.h\n> @@ -0,0 +1,585 @@\n[...]\n> +#ifndef REFTABLE_H\n> +#define REFTABLE_H\n> +\n> +#include <stdint.h>\n> +#include <stddef.h>\n\nGit tends to prefer to rely on the caller to have #include-ed\nportability gotchas around what feature test macros need to have been\nset before the first #include of a standard header.\n\n> +\n> +void reftable_set_alloc(void *(*malloc)(size_t),\n> +\t\t\tvoid *(*realloc)(void *, size_t), void (*free)(void *));\n> +\n> +/****************************************************************\n> + Basic data types\n> +\n> + Reftables store the state of each ref in struct reftable_ref_record, and they\n> + store a sequence of reflog updates in struct reftable_log_record.\n> + ****************************************************************/\n\nnit: Git style for comments would be\n\n/*\n* Basic data types\n*\n* Reftables store the state of each [etc]\n*/\n\nIn other words:\n\n- no lines of stars\n- \"/*\" with no text after it as first line\n- \" *\" leading subsequent lines\n- \" */\" as last line\n\n> +\n> +/* reftable_ref_record holds a ref database entry target_value */\n> +struct reftable_ref_record {\n> +\tchar *refname; /* Name of the ref, malloced. */\n> +\tuint64_t update_index; /* Logical timestamp at which this value is\n> +\t\t\t\t written */\n\nLikewise: Git doesn't have this style of multi-line comment, but this\ncould be e.g. a single-line comment before\n\n/* logical timestamp at which this value was written */\nuint64_t update_index;\n\n> +\tuint8_t *value; /* SHA1, or NULL. malloced. */\n\nWhat does \"NULL. malloced\" mean? Is the point that the\nreftable_ref_record owns the memory? (We don't do as good a job of\ndocumenting that as we should. Often a non-const pointer is owned,\nbut in this example it's probably better to be explicit that this\nstruct owns the memory pointed to by all its fields in the comment\ndescribing the struct as a whole.)\n\nIt would be more idiomatic for this to be a 'struct object_id' inline\nin the reftable_ref_record.\n\n> +\tuint8_t *target_value; /* peeled annotated tag, or NULL. malloced. */\n> +\tchar *target; /* symref, or NULL. malloced. */\n> +};\n> +\n> +/* returns whether 'ref' represents a deletion */\n> +int reftable_ref_record_is_deletion(const struct reftable_ref_record *ref);\n\nNice, this looks pleasant to use.\n\n> +\n> +/* prints a reftable_ref_record onto stdout */\n> +void reftable_ref_record_print(struct reftable_ref_record *ref,\n> +\t\t\t uint32_t hash_id);\n\nProbably worth being explicit about the purpose: is this for\ndebugging?\n\nWhat is a hash_id?\n\n> +\n> +/* frees and nulls all pointer values. */\n> +void reftable_ref_record_clear(struct reftable_ref_record *ref);\n> +\n> +/* returns whether two reftable_ref_records are the same */\n> +int reftable_ref_record_equal(struct reftable_ref_record *a,\n> +\t\t\t struct reftable_ref_record *b, int hash_size);\n> +\n> +/* reftable_log_record holds a reflog entry */\n> +struct reftable_log_record {\n\nShould some of this documentation mention the reftable spec? E.g. an\nopening comment at the beginning of the header. That might help avoid\nhaving to duplicate too much explanation when terminology matches.\n\n> +\tchar *refname;\n> +\tuint64_t update_index; /* logical timestamp of a transactional update.\n> +\t\t\t\t*/\n\nmultiline comment (I won't mention the rest).\n\n> +\tuint8_t *new_hash;\n> +\tuint8_t *old_hash;\n> +\tchar *name;\n> +\tchar *email;\n> +\tuint64_t time;\n> +\tint16_t tz_offset;\n> +\tchar *message;\n> +};\n> +\n> +/* returns whether 'ref' represents the deletion of a log record. */\n\nThese are a bit subtle --- should the comment include a little more\nexplanation (e.g. about how this is mostly for tools like \"git\nstash\")?\n\n> +int reftable_log_record_is_deletion(const struct reftable_log_record *log);\n> +\n> +/* frees and nulls all pointer values. */\n> +void reftable_log_record_clear(struct reftable_log_record *log);\n> +\n> +/* returns whether two records are equal. */\n> +int reftable_log_record_equal(struct reftable_log_record *a,\n> +\t\t\t struct reftable_log_record *b, int hash_size);\n> +\n> +/* dumps a reftable_log_record on stdout, for debugging/testing. */\n> +void reftable_log_record_print(struct reftable_log_record *log,\n> +\t\t\t uint32_t hash_id);\n> +\n> +/****************************************************************\n> + Error handling\n> +\n> + Error are signaled with negative integer return values. 0 means success.\n> + ****************************************************************/\n> +\n> +/* different types of errors */\n> +enum reftable_error {\n\nReminds me of zlib and liblzma. I like it.\n\n> +\t/* Unexpected file system behavior */\n> +\tREFTABLE_IO_ERROR = -2,\n> +\n> +\t/* Format inconsistency on reading data\n> +\t */\n> +\tREFTABLE_FORMAT_ERROR = -3,\n> +\n> +\t/* File does not exist. Returned from block_source_from_file(), because\n> +\t it needs special handling in stack.\n> +\t*/\n> +\tREFTABLE_NOT_EXIST_ERROR = -4,\n> +\n> +\t/* Trying to write out-of-date data. */\n> +\tREFTABLE_LOCK_ERROR = -5,\n> +\n> +\t/* Misuse of the API:\n> +\t - on writing a record with NULL refname.\n> +\t - on writing a reftable_ref_record outside the table limits\n> +\t - on writing a ref or log record before the stack's next_update_index\n> +\t - on writing a log record with multiline message with\n> +\t exact_log_message unset\n> +\t - on reading a reftable_ref_record from log iterator, or vice versa.\n> +\t*/\n> +\tREFTABLE_API_ERROR = -6,\n\nShould these call BUG()? Or is it useful for some callers to be able\nto recover from these errors?\n\n> +\n> +\t/* Decompression error */\n> +\tREFTABLE_ZLIB_ERROR = -7,\n> +\n> +\t/* Wrote a table without blocks. */\n> +\tREFTABLE_EMPTY_TABLE_ERROR = -8,\n> +\n> +\t/* Dir/file conflict. */\n\nThis is when adding a ref?\n\n> +\tREFTABLE_NAME_CONFLICT = -9,\n> +\n> +\t/* Illegal ref name. */\n> +\tREFTABLE_REFNAME_ERROR = -10,\n> +};\n> +\n> +/* convert the numeric error code to a string. The string should not be\n> + * deallocated. */\n> +const char *reftable_error_str(int err);\n\nIn the ZLIB_ERROR case this would produce a frustratingly vague\nmessage. I think I don't mind, but it might be worth a NEEDSWORK\ncomment to revisit in the future.\n\n> +\n> +/*\n> + * Convert the numeric error code to an equivalent errno code.\n> + */\n> +int reftable_error_to_errno(int err);\n\nWhat is the intended use of this function?\n\n[...]\n> +/* reftable_block_stats holds statistics for a single block type */\n> +struct reftable_block_stats {\n\nAre these for use in tracing, debugging, or some other purpose?\n\n[...]\n> +/* reftable_new_writer creates a new writer */\n> +struct reftable_writer *\n> +reftable_new_writer(int (*writer_func)(void *, const void *, size_t),\n> +\t\t void *writer_arg, struct reftable_write_options *opts);\n\nWhat is a writer? What is a writer_func? Is this a handle that\nallows me to determine where I write my reftable? (Sounds reasonable\nbut the comment could be more explicit.)\n\n[...]\n> +\n> +/* write to a file descriptor. fdp should be an int* pointing to the fd. */\n> +int reftable_fd_write(void *fdp, const void *data, size_t size);\n\nWhat does this do for interrupted writes?\n\n> +\n> +/* Set the range of update indices for the records we will add. When\n> + writing a table into a stack, the min should be at least\n> + reftable_stack_next_update_index(), or REFTABLE_API_ERROR is returned.\n> +\n> + For transactional updates, typically min==max. When converting an existing\n> + ref database into a single reftable, this would be a range of update-index\n> + timestamps.\n> + */\n> +void reftable_writer_set_limits(struct reftable_writer *w, uint64_t min,\n> +\t\t\t\tuint64_t max);\n\nWhat happens if I write to a reftable_writer without setting limits\nfirst?\n\n> +\n> +/* adds a reftable_ref_record. Must be called in ascending\n> + order. The update_index must be within the limits set by\n> + reftable_writer_set_limits(), or REFTABLE_API_ERROR is returned.\n> +\n> + It is an error to write a ref record after a log record.\n> + */\n> +\t\t\t struct reftable_ref_record *ref);\n\noptional: since it's called a writer, _write_ref() feels like a\nslightly more natural verb (likewise for the others).\n\n[...]\n> +/* adds a reftable_log_record. Must be called in ascending order (with more\n> + recent log entries first.)\n> + */\n> +\t\t\t struct reftable_log_record *log);\n\nIf I want to write multiple log records with the same update_index to\nrepresent a multi-ref transaction, do I have to do anything careful?\n\n> +\n> +/* Convenience function to add multiple logs. Will sort the records by\n> + key before adding. */\n> +\t\t\t struct reftable_log_record *logs, int n);\n> +\n> +/* reftable_writer_close finalizes the reftable. The writer is retained so\n> + * statistics can be inspected. */\n> +int reftable_writer_close(struct reftable_writer *w);\n\nNice.\n\n> +\n> +/* writer_stats returns the statistics on the reftable being written.\n> +\n> + This struct becomes invalid when the writer is freed.\n> + */\n> +const struct reftable_stats *writer_stats(struct reftable_writer *w);\n\nAlso nice.\n\n[...]\n> +/* iterator is the generic interface for walking over data stored in a\n> + reftable. It is generally passed around by value.\n> +*/\n> +struct reftable_iterator {\n> +\tstruct reftable_iterator_vtable *ops;\n> +\tvoid *iter_arg;\n> +};\n\nEven small structs like this one tend not to be passed by value in the\nGit codebase. The only counterexample I found with a quick search\n(builtin/stash.c::save_untracked_files) appears to be a typo.\n\n[...]\n> +/* a contiguous segment of bytes. It keeps track of its generating block_source\n> + so it can return itself into the pool.\n> +*/\n> +struct reftable_block {\n> +\tuint8_t *data;\n> +\tint len;\n> +\tstruct reftable_block_source source;\n> +};\n\nIs this something that could use mem-pool.h?\n\n> +/* block_source_vtable are the operations that make up block_source */\n> +struct reftable_block_source_vtable {\n> +\t/* returns the size of a block source */\n> +\tuint64_t (*size)(void *source);\n> +\n> +\t/* reads a segment from the block source. It is an error to read\n> +\t beyond the end of the block */\n> +\tint (*read_block)(void *source, struct reftable_block *dest,\n> +\t\t\t uint64_t off, uint32_t size);\n> +\t/* mark the block as read; may return the data back to malloc */\n> +\tvoid (*return_block)(void *source, struct reftable_block *blockp);\n> +\n> +\t/* release all resources associated with the block source */\n> +\tvoid (*close)(void *source);\n> +};\n\nThis is abstracting file input? I wonder if some name emphasizing the\n\nDo I pass in the 'struct block_source *' as the source arg? If so, why\nare these declared as void *?\n\nIs the reason this manages the buffer instead of requiring a\ncaller-supplied buffer to support zero-copy?\n\n[...]\n> +\n> +/* opens a file on the file system as a block_source */\n> +int reftable_block_source_from_file(struct reftable_block_source *block_src,\n> +\t\t\t\t const char *name);\n> +\n> +/* The reader struct is a handle to an open reftable file. */\n\n... ah, this is why the underlying file handle isn't called a reader.\nHmm.\n\n[...]\n> +/* reftable_reader_seek_ref returns an iterator where 'name' would be inserted\n> + in the table. To seek to the start of the table, use name = \"\".\n\nnit: s/iterator where/iterator pointing where/\n\n> +\n> + example:\n> +\n> + struct reftable_reader *r = NULL;\n> + int err = reftable_new_reader(&r, &src, \"filename\");\n> + if (err < 0) { ... }\n> + struct reftable_iterator it = {0};\n> + if (err < 0) { ... }\n> + struct reftable_ref_record ref = {0};\n> + while (1) {\n> + err = reftable_iterator_next_ref(&it, &ref);\n> + if (err > 0) {\n> + break;\n> + }\n> + if (err < 0) {\n> + ..error handling..\n> + }\n> + ..found..\n> + }\n> + reftable_iterator_destroy(&it);\n> + reftable_ref_record_clear(&ref);\n\nNice.\n\n> + */\n> +\t\t\t struct reftable_iterator *it, const char *name);\n> +\n> +/* returns the hash ID used in this table. */\n\nWhat is a hash id?\n\n[...]\n> + Merged tables\n> +\n> + A ref database kept in a sequence of table files. The merged_table presents a\n> + unified view to reading (seeking, iterating) a sequence of immutable tables.\n\nNice as well.\n\n[...]\n> +/* returns the max update_index covered by this merged table. */\n> +uint64_t\n> +reftable_merged_table_max_update_index(struct reftable_merged_table *mt);\n\nnit: return type should be on the same line as the function name\n\nuint64_t reftable_merged_table_max_update_index(\nstruct reftable_merged_table *mt);\n\n[...]\n> + Generic tables\n> +\n> + A unified API for reading tables, either merged tables, or single readers.\n\nAre there callers/helpers that don't know whether they want one or the\nother?\n\n[...]\n> + * a stack is a stack of reftables, which can be mutated by pushing a table to\n> + * the top of the stack\n\nNice.\n\n[...]\n> +/* holds a transaction to add tables at the top of a stack. */\n\nWhen would I add multiple tables at once to the top? Is this used\nduring compacting, for example?\n\n[...]\n> +/* heuristically compact unbalanced table stack. */\n> +int reftable_stack_auto_compact(struct reftable_stack *st);\n\nWhen do I call this? What are the semantics? (By this I don't mean\nwhat heuristic does it use, but what expectation should I have as a\ncaller?)\n\n> +/* convenience function to read a single log. Returns < 0 for error, 0\n> +int reftable_stack_read_log(struct reftable_stack *st, const char *refname,\n> +\t\t\t struct reftable_log_record *log);\n\nnit: single log *record*?\n\n> +/* statistics on past compactions. */\n> +struct reftable_compaction_stats {\n> +\tuint64_t bytes; /* total number of bytes written */\n> +\tuint64_t entries_written; /* total number of entries written, including\n> +\t\t\t\t failures. */\n> +\tint attempts; /* how often we tried to compact */\n> +\tint failures; /* failures happen on concurrent updates */\n> +};\n> +\n> +/* return statistics for compaction up till now. */\n> +struct reftable_compaction_stats *\n> +reftable_stack_compaction_stats(struct reftable_stack *st);\n\nAll in all, I like this API. Thanks for putting it together\nthoughtfully.\n\nThe API builds up in layers (blocks, reftables, merged reftables, etc),\nsuggesting a natural division for the patch series. I think the rest of\nthe series follows that --- let's see.\n\nThanks,\nJonathan\n\n• ```* Re: [PATCH v2 02/13] reftable: define the public API\n2020-10-02 3:58 ` Jonathan Nieder\n@ 2020-10-09 21:13 ` Emily Shaffer\n2020-10-10 17:03 ` Han-Wen Nienhuys\n2020-11-30 14:44 ` Han-Wen Nienhuys\n2020-10-10 13:43 ` Han-Wen Nienhuys\n1 sibling, 2 replies; 251+ messages in thread\nFrom: Emily Shaffer @ 2020-10-09 21:13 UTC (permalink / raw)\nTo: Jonathan Nieder\nCc: Han-Wen Nienhuys via GitGitGadget, git, Han-Wen Nienhuys,\nJeff King, Han-Wen Nienhuys\n\nOn Thu, Oct 01, 2020 at 08:58:51PM -0700, Jonathan Nieder wrote:\n>\n> Hi,\n>\n> Han-Wen Nienhuys wrote:\n>\n> > reftable/reftable.h | 585 ++++++++++++++++++++++++++++++++++++++++++++\n> > 1 file changed, 585 insertions(+)\n> > create mode 100644 reftable/reftable.h\n>\n> Adding a header in a separate patch from the implementation doesn't\n> match the usual practice. Can we add declarations in the same patch\n> as the functions being declared instead?\n>\n> We could still introduce the header early in its own patch if we want,\n> but it would be a skeleton of a header that gets filled out by later\n> patches.\n\nTo poke a little deeper into what I think Jonathan is trying to say:\n\nWhen we reviewed this for review club, the general feeling was that A)\nthis commit structure is still pretty difficult to review, and B) we\nwant to make sure you aren't spending a ton of time reorganizing the\ncode only to find that people still don't like the structure (as may\nhave happened with the current iteration).\n\nOne point I think Jonathan is making is that each commit should stand\nalone: compile, be tested, and do something succinct. Another point (or\nmaybe the same point from a different angle) is that a series of commits\nshould tell a progressive story. That is, something like\n\nadd infrastructure to support reftable library\nreftable: write files\nreftable: generate binary tree from file\n...\n\nis much more compelling (and easier to review) than\n\nreftable: tests\n...\n\nTowards the latter end of your series it seems like you started to take\nthat approach; but some commits, like this one (reftable: define the\npublic API) are not quite so. That is, this commit is hard to review\nwithout the context of the rest of the series: I read it, I say, \"well\nWHY do we need these functions?\", and then I cannot continue my review\nof this patch until I've completed my review of the rest of the series.\n\nOf course, taking a completed project - like your initial reftable\nsubmission - and then chopping it up into a cute story of commits is a\npain in the ***. Doing it twice - or more - is just aggravating. So I\nwonder whether we can bikeshed what story would look nice before you\neven pick up your 'git rebase -i'? Doing that bikeshedding here on list\nmeans that we also have a chance for someone to interrupt and say, \"no,\nthat organization doesn't make sense\" - or even for someone to say\n\"Emily, there is no need to reorganize these commits, go sit down\" ;)\n\n> All in all, I like this API. Thanks for putting it together\n> thoughtfully.\n>\n> The API builds up in layers (blocks, reftables, merged reftables, etc),\n> suggesting a natural division for the patch series. I think the rest of\n> the series follows that --- let's see.\n\nOr maybe what I said runs contrary to what Jonathan was actually saying.\n\n- Emily\n\n• ```* Re: [PATCH v2 02/13] reftable: define the public API\n2020-10-09 21:13 ` Emily Shaffer\n@ 2020-10-10 17:03 ` Han-Wen Nienhuys\n2020-11-30 14:44 ` Han-Wen Nienhuys\n1 sibling, 0 replies; 251+ messages in thread\nFrom: Han-Wen Nienhuys @ 2020-10-10 17:03 UTC (permalink / raw)\nTo: Emily Shaffer\nCc: Jonathan Nieder, Han-Wen Nienhuys via GitGitGadget, git,\nJeff King, Han-Wen Nienhuys\n\nOn Fri, Oct 9, 2020 at 11:13 PM Emily Shaffer <[email protected]> wrote:\n> Of course, taking a completed project - like your initial reftable\n> submission - and then chopping it up into a cute story of commits is a\n> pain in the ***. Doing it twice - or more - is just aggravating. So I\n> wonder whether we can bikeshed what story would look nice before you\n> even pick up your 'git rebase -i'? Doing that bikeshedding here on list\n> means that we also have a chance for someone to interrupt and say, \"no,\n> that organization doesn't make sense\" - or even for someone to say\n\nThat said, I think it's worthwhile to first look at the commit that\nuses the library to implement a ref backend, because that will show\nbetter how the reftable library fits with the way that Git likes to\nconsume its data.\n\n--\nI work 80%. Don't expect answers from me on Fridays.\n--\n\nGoogle Germany GmbH, Erika-Mann-Strasse 33, 80636 Munich\n\nRegistergericht und -nummer: Hamburg, HRB 86891\n\nSitz der Gesellschaft: Hamburg\n\nGeschäftsführer: Paul Manicle, Halimah DeLaine Prado\n\n• ```* Re: [PATCH v2 02/13] reftable: define the public API\n2020-10-09 21:13 ` Emily Shaffer\n2020-10-10 17:03 ` Han-Wen Nienhuys\n@ 2020-11-30 14:44 ` Han-Wen Nienhuys\n1 sibling, 0 replies; 251+ messages in thread\nFrom: Han-Wen Nienhuys @ 2020-11-30 14:44 UTC (permalink / raw)\nTo: Emily Shaffer\nCc: Jonathan Nieder, Han-Wen Nienhuys via GitGitGadget, git,\nJeff King, Han-Wen Nienhuys\n\nOn Fri, Oct 9, 2020 at 11:13 PM Emily Shaffer <[email protected]> wrote:\n>\n> On Thu, Oct 01, 2020 at 08:58:51PM -0700, Jonathan Nieder wrote:\n> >\n> > Hi,\n> >\n> > Han-Wen Nienhuys wrote:\n> >\n> > > reftable/reftable.h | 585 ++++++++++++++++++++++++++++++++++++++++++++\n> > > 1 file changed, 585 insertions(+)\n> > > create mode 100644 reftable/reftable.h\n> >\n> > Adding a header in a separate patch from the implementation doesn't\n> > match the usual practice. Can we add declarations in the same patch\n> > as the functions being declared instead?\n> >\n> > We could still introduce the header early in its own patch if we want,\n> > but it would be a skeleton of a header that gets filled out by later\n> > patches.\n>\n> To poke a little deeper into what I think Jonathan is trying to say:\n>\n> Of course, taking a completed project - like your initial reftable\n> submission - and then chopping it up into a cute story of commits is a\n> pain in the ***. Doing it twice - or more - is just aggravating. So I\n> wonder whether we can bikeshed what story would look nice before you\n> even pick up your 'git rebase -i'? Doing that bikeshedding here on list\n\nLooks like this didn't happen. I went with Jonathan's suggestion, and\nchopped the public API header in smaller bits. PTAL.\n\n--\nI work 80%. Don't expect answers from me on Fridays.\n--\n\nGoogle Germany GmbH, Erika-Mann-Strasse 33, 80636 Munich\n\nRegistergericht und -nummer: Hamburg, HRB 86891\n\nSitz der Gesellschaft: Hamburg\n\nGeschäftsführer: Paul Manicle, Halimah DeLaine Prado\n\n• ```* Re: [PATCH v2 02/13] reftable: define the public API\n2020-10-02 3:58 ` Jonathan Nieder\n2020-10-09 21:13 ` Emily Shaffer\n@ 2020-10-10 13:43 ` Han-Wen Nienhuys\n2020-10-12 16:57 ` Jonathan Nieder\nFrom: Han-Wen Nienhuys @ 2020-10-10 13:43 UTC (permalink / raw)\nTo: Jonathan Nieder\nCc: Han-Wen Nienhuys via GitGitGadget, git, Jeff King, Han-Wen Nienhuys\n\nOn Fri, Oct 2, 2020 at 5:58 AM Jonathan Nieder <[email protected]> wrote:\n> Adding a header in a separate patch from the implementation doesn't\n> match the usual practice. Can we add declarations in the same patch\n> as the functions being declared instead?\n\nWe could, but it would considerably complicate work on this patch\nseries, as the commit boundary then doesn't fall on file boundaries\nanymore. Would you be open to having multiple headers for the public\ninterface? eg. reftable-record.h, reftable-reader.h etc. ?\n\n> > + /* Misuse of the API:\n> > + - on writing a record with NULL refname.\n> > + - on writing a reftable_ref_record outside the table limits\n> > + - on writing a ref or log record before the stack's next_update_index\n> > + - on writing a log record with multiline message with\n> > + exact_log_message unset\n> > + - on reading a reftable_ref_record from log iterator, or vice versa.\n> > + */\n> > + REFTABLE_API_ERROR = -6,\n>\n> Should these call BUG()? Or is it useful for some callers to be able\n> to recover from these errors?\n\nSince this was written as a standalone library, it's up to the caller\nto decide what should be done. It also simplifies testing: you can\nverify that incorrect API usage returns a certain error code, but a\nBUG() that prints an error or crashes the program is much harder to\nverify.\n\n> > + /* Dir/file conflict. */\n>\n> This is when adding a ref?\n\nyes.\n\n> > +\n> > +/*\n> > + * Convert the numeric error code to an equivalent errno code.\n> > + */\n> > +int reftable_error_to_errno(int err);\n>\n> What is the intended use of this function?\n\nThe read_raw_ref method in the ref backend API uses errno values as\nout-of-band communication mechanism.\n\n> > +/* Set the range of update indices for the records we will add. When\n> > + writing a table into a stack, the min should be at least\n> > + reftable_stack_next_update_index(), or REFTABLE_API_ERROR is returned.\n> > +\n> > + For transactional updates, typically min==max. When converting an existing\n> > + ref database into a single reftable, this would be a range of update-index\n> > + timestamps.\n> > + */\n> > +void reftable_writer_set_limits(struct reftable_writer *w, uint64_t min,\n> > + uint64_t max);\n>\n> What happens if I write to a reftable_writer without setting limits\n> first?\n\nyou get an REFTABLE_API_ERROR.\n\n> > +/* block_source_vtable are the operations that make up block_source */\n> > +struct reftable_block_source_vtable {\n> > + /* returns the size of a block source */\n> > + uint64_t (*size)(void *source);\n> > +\n> > + /* reads a segment from the block source. It is an error to read\n> > + beyond the end of the block */\n> > + int (*read_block)(void *source, struct reftable_block *dest,\n> > + uint64_t off, uint32_t size);\n> > + /* mark the block as read; may return the data back to malloc */\n> > + void (*return_block)(void *source, struct reftable_block *blockp);\n> > +\n> > + /* release all resources associated with the block source */\n> > + void (*close)(void *source);\n> > +};\n>\n> This is abstracting file input? I wonder if some name emphasizing the\n>\n> Do I pass in the 'struct block_source *' as the source arg? If so, why\n> are these declared as void *?\n\nyou pass in block_source->arg. Should struct implementations of\npolymorphic types carry a pointer to their own vtable instead?\n\n> Is the reason this manages the buffer instead of requiring a\n> caller-supplied buffer to support zero-copy?\n\nLog blocks are compressed, so the caller doesn't know the correct size\nto supply. By letting the block source handle the management, we can\nswap out the block read from the file for a block managed by malloc on\ndecompressing a log block.\n\n> > +/* returns the hash ID used in this table. */\n>\n> What is a hash id?\n\nThe hash identifier, eg. \"sha1\" for SHA1 and \"s256\" for SHA-256.\n\n> [...]\n> > + Generic tables\n> > +\n> > + A unified API for reading tables, either merged tables, or single readers.\n>\n> Are there callers/helpers that don't know whether they want one or the\n> other?\n\nThe setup with per-worktree refs means that there are two reftable\nstacks in a .git repo. In order to iterate over the entire ref space,\nyou have to merge two merged tables, but the stack itslef merges a set\nof simple reftables.\n\n> [...]\n> > +/* holds a transaction to add tables at the top of a stack. */\n>\n> When would I add multiple tables at once to the top? Is this used\n> during compacting, for example?\n\nNo. You'd usually add only one table, but at the same time, it seemed\nkind of arbitrary to allow adding only one table. FWIW, I added this\nbecause libgit2 wants to be able to lock a ref database: creating the\n\n--\nI work 80%. Don't expect answers from me on Fridays.\n--\n\nGoogle Germany GmbH, Erika-Mann-Strasse 33, 80636 Munich\n\nRegistergericht und -nummer: Hamburg, HRB 86891\n\nSitz der Gesellschaft: Hamburg\n\nGeschäftsführer: Paul Manicle, Halimah DeLaine Prado\n\n• ```* Re: [PATCH v2 02/13] reftable: define the public API\n2020-10-10 13:43 ` Han-Wen Nienhuys\n@ 2020-10-12 16:57 ` Jonathan Nieder\n2020-11-30 14:55 ` Han-Wen Nienhuys\nFrom: Jonathan Nieder @ 2020-10-12 16:57 UTC (permalink / raw)\nTo: Han-Wen Nienhuys\nCc: Han-Wen Nienhuys via GitGitGadget, git, Jeff King, Han-Wen Nienhuys\n\nHan-Wen Nienhuys wrote:\n> On Fri, Oct 2, 2020 at 5:58 AM Jonathan Nieder <[email protected]> wrote:\n\n>> Adding a header in a separate patch from the implementation doesn't\n>> match the usual practice. Can we add declarations in the same patch\n>> as the functions being declared instead?\n>\n> We could, but it would considerably complicate work on this patch\n> series, as the commit boundary then doesn't fall on file boundaries\n> anymore. Would you be open to having multiple headers for the public\n> interface? eg. reftable-record.h, reftable-reader.h etc. ?\n\nI'd be more than open to it: I think that would make for a clearer API.\n\nFor example, a caller like refs.c wouldn't have any need to use\nreftable-block.h because that's a lower-level detail that operates\nbehind the scenes when operating on a stack of reftables. So I think\nthis would be a good step toward addressing the feedback Jonathan gave\nabout the set of functions exposed by the API being overwhelming.\n\n>>> + /* Misuse of the API:\n>>> + - on writing a record with NULL refname.\n>>> + - on writing a reftable_ref_record outside the table limits\n>>> + - on writing a ref or log record before the stack's next_update_index\n>>> + - on writing a log record with multiline message with\n>>> + exact_log_message unset\n>>> + - on reading a reftable_ref_record from log iterator, or vice versa.\n>>> + */\n>>> + REFTABLE_API_ERROR = -6,\n>>\n>> Should these call BUG()? Or is it useful for some callers to be able\n>> to recover from these errors?\n>\n> Since this was written as a standalone library, it's up to the caller\n> to decide what should be done.\n\nimplies that the library would need to make sure it is producing a\nvalid state in error cases.\n\nDoes the API documentation describe what state a handle is in after\nan error --- e.g., what operations are permitted after that?\n\n>>> +\n>>> +/*\n>>> + * Convert the numeric error code to an equivalent errno code.\n>>> + */\n>>> +int reftable_error_to_errno(int err);\n>>\n>> What is the intended use of this function?\n>\n> The read_raw_ref method in the ref backend API uses errno values as\n> out-of-band communication mechanism.\n\nCould we change that? It sounds error-prone.\n\n[...]\n>>> +/* Set the range of update indices for the records we will add. When\n>>> + writing a table into a stack, the min should be at least\n>>> + reftable_stack_next_update_index(), or REFTABLE_API_ERROR is returned.\n>>> +\n>>> + For transactional updates, typically min==max. When converting an existing\n>>> + ref database into a single reftable, this would be a range of update-index\n>>> + timestamps.\n>>> + */\n>>> +void reftable_writer_set_limits(struct reftable_writer *w, uint64_t min,\n>>> + uint64_t max);\n>>\n>> What happens if I write to a reftable_writer without setting limits\n>> first?\n>\n> you get an REFTABLE_API_ERROR.\n\n(To be clear, with all of these questions, I am asking not only for my\nown curiosity but so that the documentation, naming, etc can be\ncleared up to help the next person who wonders the same thing.)\n\n[...]\n>> Do I pass in the 'struct block_source *' as the source arg? If so, why\n>> are these declared as void *?\n>\n> you pass in block_source->arg. Should struct implementations of\n> polymorphic types carry a pointer to their own vtable instead?\n\nI think a pointer to block_source would make it more self-explanatory,\nyes.\n\n(Aside: this is a difference between how Go and e.g. Java and C++\nimplement polymorphism. In Go, an interface object contains a vtable\nand a pointer to the object. In Java and C++, the object contains a\nvptr.)\n\n>> Is the reason this manages the buffer instead of requiring a\n>> caller-supplied buffer to support zero-copy?\n>\n> Log blocks are compressed, so the caller doesn't know the correct size\n> to supply. By letting the block source handle the management, we can\n> swap out the block read from the file for a block managed by malloc on\n> decompressing a log block.\n\nHm, my naive assumption would have been that we'd use different\nbuffers for the compressed and uncompressed data.\n\n>>> + Generic tables\n>>> +\n>>> + A unified API for reading tables, either merged tables, or single readers.\n>>\n>> Are there callers/helpers that don't know whether they want one or the\n>> other?\n>\n> The setup with per-worktree refs means that there are two reftable\n> stacks in a .git repo. In order to iterate over the entire ref space,\n> you have to merge two merged tables, but the stack itslef merges a set\n> of simple reftables.\n\nI see. That's subtle, so it seems worth documenting for the next\nperson reading this documentation and wondering why.\n\nThanks,\nJonathan\n\n• ```* Re: [PATCH v2 02/13] reftable: define the public API\n2020-10-12 16:57 ` Jonathan Nieder\n@ 2020-11-30 14:55 ` Han-Wen Nienhuys\n0 siblings, 0 replies; 251+ messages in thread\nFrom: Han-Wen Nienhuys @ 2020-11-30 14:55 UTC (permalink / raw)\nTo: Jonathan Nieder\nCc: Han-Wen Nienhuys via GitGitGadget, git, Jeff King, Han-Wen Nienhuys\n\nOn Mon, Oct 12, 2020 at 6:57 PM Jonathan Nieder <[email protected]> wrote:\n> > We could, but it would considerably complicate work on this patch\n> > series, as the commit boundary then doesn't fall on file boundaries\n> > anymore. Would you be open to having multiple headers for the public\n> > interface? eg. reftable-record.h, reftable-reader.h etc. ?\n>\n> I'd be more than open to it: I think that would make for a clearer API.\n\nDone.\n\n> >> Should these call BUG()? Or is it useful for some callers to be able\n> >> to recover from these errors?\n> >\n> > Since this was written as a standalone library, it's up to the caller\n> > to decide what should be done.\n>\n> implies that the library would need to make sure it is producing a\n> valid state in error cases.\n\nThis is what it already does. I tried to clarify this in some places.\n\n> Does the API documentation describe what state a handle is in after\n> an error --- e.g., what operations are permitted after that?\n\nAPI_ERROR should not result in state changes.\n\n> >>> +int reftable_error_to_errno(int err);\n> >>\n> >> What is the intended use of this function?\n> >\n> > The read_raw_ref method in the ref backend API uses errno values as\n> > out-of-band communication mechanism.\n>\n> Could we change that? It sounds error-prone.\n\nI moved it into refs/reftable-backend.c; I'd rather not also have to\nclean up the files backend as part of this work, though.\n\n> >> Do I pass in the 'struct block_source *' as the source arg? If so, why\n> >> are these declared as void *?\n> >\n> > you pass in block_source->arg. Should struct implementations of\n> > polymorphic types carry a pointer to their own vtable instead?\n>\n> I think a pointer to block_source would make it more self-explanatory,\n> yes.\n\nThis has a number of downsides, though. It means I have to introduce\nseparate structs strbuf_blocksource and file_blocksource, along with\nfunctions to create and deallocate them, so it makes the whole thing\nmore unwieldy to use.\n\n> >> Is the reason this manages the buffer instead of requiring a\n> >> caller-supplied buffer to support zero-copy?\n> >\n> > Log blocks are compressed, so the caller doesn't know the correct size\n> > to supply. By letting the block source handle the management, we can\n> > swap out the block read from the file for a block managed by malloc on\n> > decompressing a log block.\n>\n> Hm, my naive assumption would have been that we'd use different\n> buffers for the compressed and uncompressed data.\n\nMaybe you can comment on how to solve this differently when we get to\nthe implementation of block reading/writing in the commit series.\n\n> >>> + Generic tables\n> >>> +\n> >>> + A unified API for reading tables, either merged tables, or single readers.\n> >>\n> >> Are there callers/helpers that don't know whether they want one or the\n> >> other?\n> >\n> > The setup with per-worktree refs means that there are two reftable\n> > stacks in a .git repo. In order to iterate over the entire ref space,\n> > you have to merge two merged tables, but the stack itslef merges a set\n> > of simple reftables.\n>\n> I see. That's subtle, so it seems worth documenting for the next\n> person reading this documentation and wondering why.\n\nDone.\n\n--\nI work 80%. Don't expect answers from me on Fridays.\n--\n\nGoogle Germany GmbH, Erika-Mann-Strasse 33, 80636 Munich\n\nRegistergericht und -nummer: Hamburg, HRB 86891\n\nSitz der Gesellschaft: Hamburg\n\nGeschäftsführer: Paul Manicle, Halimah DeLaine Prado\n\n• ```* Re: [PATCH v2 02/13] reftable: define the public API\n2020-10-01 16:10 ` [PATCH v2 02/13] reftable: define the public API Han-Wen Nienhuys via GitGitGadget\n2020-10-02 3:58 ` Jonathan Nieder\n@ 2020-10-08 1:41 ` Jonathan Tan\n2020-10-10 16:57 ` Han-Wen Nienhuys\nFrom: Jonathan Tan @ 2020-10-08 1:41 UTC (permalink / raw)\nTo: gitgitgadget; +Cc: git, hanwen, peff, Jonathan Tan\n\nMy initial impression is that this public API is much larger than I\nwould expect from reading the reftable spec. Let me look at it in\ndetail...\n\n> +/****************************************************************\n> + Basic data types\n> +\n> + Reftables store the state of each ref in struct reftable_ref_record, and they\n> + store a sequence of reflog updates in struct reftable_log_record.\n> + ****************************************************************/\n> +\n> +/* reftable_ref_record holds a ref database entry target_value */\n> +struct reftable_ref_record {\n> +\tchar *refname; /* Name of the ref, malloced. */\n> +\tuint64_t update_index; /* Logical timestamp at which this value is\n> +\t\t\t\t written */\n> +\tuint8_t *value; /* SHA1, or NULL. malloced. */\n> +\tuint8_t *target_value; /* peeled annotated tag, or NULL. malloced. */\n> +\tchar *target; /* symref, or NULL. malloced. */\n> +};\n\nA typical user would just want to do refname->hash, refname->log, or possibly\nhash->refname lookups, so a ref record would be meant for low-level\nusers. I can't think of a typical use case, but even if such existed, I\nwouldn't expect this API - in particular, the refname is not written as\nsuch on disk (it is composed from a prefix and a suffix, if I remember\ncorrectly), so I would expect a function that one can call to write the\nrefname, but not for it to appear in a data structure.\n\n> +/* returns whether 'ref' represents a deletion */\n> +int reftable_ref_record_is_deletion(const struct reftable_ref_record *ref);\n\nThis looks unorthogonal - looking at the spec, the \"value type\" can\nrepresent a deletion, one object name (value of the ref), two object\nnames (value of the ref + peeled target), or symbolic reference. If\nwe're willing to allocate memory for a ref record, I think we can afford\nthe extra 4 bytes (maybe 8) and use a tagged union instead.\n\n> +/* prints a reftable_ref_record onto stdout */\n> +void reftable_ref_record_print(struct reftable_ref_record *ref,\n> +\t\t\t uint32_t hash_id);\n\nNot sure if this belongs here.\n\n> +/* frees and nulls all pointer values. */\n> +void reftable_ref_record_clear(struct reftable_ref_record *ref);\n\nUsually we call this \"release\" in Git.\n\n> +/* returns whether two reftable_ref_records are the same */\n> +int reftable_ref_record_equal(struct reftable_ref_record *a,\n> +\t\t\t struct reftable_ref_record *b, int hash_size);\n\nNot sure what this will be used for.\n\n> +/* reftable_log_record holds a reflog entry */\n> +struct reftable_log_record {\n> +\tchar *refname;\n> +\tuint64_t update_index; /* logical timestamp of a transactional update.\n> +\t\t\t\t*/\n> +\tuint8_t *new_hash;\n> +\tuint8_t *old_hash;\n> +\tchar *name;\n> +\tchar *email;\n> +\tuint64_t time;\n> +\tint16_t tz_offset;\n> +\tchar *message;\n> +};\n\n[snip]\n\n> +/****************************************************************\n> + Error handling\n> +\n> + Error are signaled with negative integer return values. 0 means success.\n> + ****************************************************************/\n\nI didn't look at this section deeply, but this looks OK at first glance.\n\n> +/****************************************************************\n> + Writing\n> +\n> + Writing single reftables\n> + ****************************************************************/\n\nOK - writing a single reftable makes sense.\n\n> +/* reftable_write_options sets options for writing a single reftable. */\n> +struct reftable_write_options {\n> +\t/* boolean: do not pad out blocks to block size. */\n> +\n> +\t/* the blocksize. Should be less than 2^24. */\n> +\tuint32_t block_size;\n> +\n> +\t/* boolean: do not generate a SHA1 => ref index. */\n> +\tint skip_index_objects;\n> +\n> +\t/* how often to write complete keys in each block. */\n> +\tint restart_interval;\n> +\n> +\t/* 4-byte identifier (\"sha1\", \"s256\") of the hash.\n> +\t * Defaults to SHA1 if unset\n> +\t */\n> +\tuint32_t hash_id;\n> +\n> +\t/* boolean: do not check ref names for validity or dir/file conflicts.\n> +\t */\n> +\tint skip_name_check;\n> +\n> +\t/* boolean: copy log messages exactly. If unset, check that the message\n> +\t * is a single line, and add '\\n' if missing.\n> +\t */\n> +\tint exact_log_message;\n> +};\n\nI'm not sure we need so many options, but nothing jumps out to me\noff-hand. Some minor things - \"hash_id\" should probably be an enum and\nthe booleans should be \"unsigned variable_name : 1\".\n\n[snip statistics]\n\nStatistics look useful.\n\n> +/* reftable_new_writer creates a new writer */\n> +struct reftable_writer *\n> +reftable_new_writer(int (*writer_func)(void *, const void *, size_t),\n> +\t\t void *writer_arg, struct reftable_write_options *opts);\n> +\n> +/* write to a file descriptor. fdp should be an int* pointing to the fd. */\n> +int reftable_fd_write(void *fdp, const void *data, size_t size);\n\nNot sure if we'll need to write to things other than an fd, but if we\ndo, this makes sense.\n\n> +/* Set the range of update indices for the records we will add. When\n> + writing a table into a stack, the min should be at least\n> + reftable_stack_next_update_index(), or REFTABLE_API_ERROR is returned.\n> +\n> + For transactional updates, typically min==max. When converting an existing\n> + ref database into a single reftable, this would be a range of update-index\n> + timestamps.\n> + */\n> +void reftable_writer_set_limits(struct reftable_writer *w, uint64_t min,\n> +\t\t\t\tuint64_t max);\n\nThis seems to be here because we want to write the file in a single\npass, and the update index maximum and minimum appear in the header. If\nwe were allowed to seek while writing, could the update index maximum\nand minimum be deduced instead? That might be a compelling reason to\nonly support FDs, and require that the FDs be seekable.\n\n> +/* adds a reftable_ref_record. Must be called in ascending\n> + order. The update_index must be within the limits set by\n> + reftable_writer_set_limits(), or REFTABLE_API_ERROR is returned.\n> +\n> + It is an error to write a ref record after a log record.\n> + */\n> +\t\t\t struct reftable_ref_record *ref);\n> +\n> +/* Convenience function to add multiple refs. Will sort the refs by\n> + name before adding. */\n> +\t\t\t struct reftable_ref_record *refs, int n);\n\nSince refs is an array of objects and not an array of pointers, these\ntwo functions could be combined - the first is the same as calling the\nsecond with n=1.\n\nAlso, ascending order of what?\n\nThe user will also need to know where to get the update index from - I\npresume that this will be the maximum update index of any record with\nthe given refname + 1.\n\n[snip similar functions for log]\n\n> +/* reftable_writer_close finalizes the reftable. The writer is retained so\n> + * statistics can be inspected. */\n> +int reftable_writer_close(struct reftable_writer *w);\n> +\n> +/* writer_stats returns the statistics on the reftable being written.\n> +\n> + This struct becomes invalid when the writer is freed.\n> + */\n> +const struct reftable_stats *writer_stats(struct reftable_writer *w);\n> +\n> +/* reftable_writer_free deallocates memory for the writer */\n> +void reftable_writer_free(struct reftable_writer *w);\n\nOK.\n\n> +/****************************************************************\n> + * ITERATING\n> + ****************************************************************/\n\n[snip]\n\n> +/* reads the next reftable_ref_record. Returns < 0 for error, 0 for OK and > 0:\n> + end of iteration.\n> +*/\n> +int reftable_iterator_next_ref(struct reftable_iterator *it,\n> +\t\t\t struct reftable_ref_record *ref);\n> +\n> +/* reads the next reftable_log_record. Returns < 0 for error, 0 for OK and > 0:\n> + end of iteration.\n> +*/\n> +int reftable_iterator_next_log(struct reftable_iterator *it,\n> +\t\t\t struct reftable_log_record *log);\n\nFrom my recollection, in Git, we typically use foreach functions with a\ncallback that is invoked once for each result. I think that's preferable\nto this approach.\n\n> +/****************************************************************\n> +\n> + The follow routines are for reading single files. For an application-level\n> + interface, skip ahead to struct reftable_merged_table and struct\n> + reftable_stack.\n> + ****************************************************************/\n\nI think that this whole section could be skipped - if we really wanted\nto read a single table, we could just use the merged-table interface\nwith one table.\n\n[snip]\n\n> +/****************************************************************\n> + Merged tables\n> +\n> + A ref database kept in a sequence of table files. The merged_table presents a\n> + unified view to reading (seeking, iterating) a sequence of immutable tables.\n> + ****************************************************************/\n> +\n> +/* A merged table is implements seeking/iterating over a stack of tables. */\n> +struct reftable_merged_table;\n> +\n> +/* A generic reftable; see below. */\n> +struct reftable_table;\n\nWhy would we need to see an individual reftable? Could we just represent\na merged table as a virtual concatenation of blocks (as if all the\nblocks were in the same file)?\n\n> +/* reftable_new_merged_table creates a new merged table. It takes ownership of\n> + the stack array.\n> +*/\n> +int reftable_new_merged_table(struct reftable_merged_table **dest,\n> +\t\t\t struct reftable_table *stack, int n,\n> +\t\t\t uint32_t hash_id);\n\nI presume this would be used for things like compacting a few reftables\ntogether? In which case, I would expect this function to just take a\nlist of filenames.\n\n> +/* returns an iterator positioned just before 'name' */\n> +int reftable_merged_table_seek_ref(struct reftable_merged_table *mt,\n> +\t\t\t\t struct reftable_iterator *it,\n> +\t\t\t\t const char *name);\n> +\n> +/* returns an iterator for log entry, at given update_index */\n> +int reftable_merged_table_seek_log_at(struct reftable_merged_table *mt,\n> +\t\t\t\t struct reftable_iterator *it,\n> +\t\t\t\t const char *name, uint64_t update_index);\n> +\n> +/* like reftable_merged_table_seek_log_at but look for the newest entry. */\n> +int reftable_merged_table_seek_log(struct reftable_merged_table *mt,\n> +\t\t\t\t struct reftable_iterator *it,\n> +\t\t\t\t const char *name);\n\nWhy do iterators need to be precisely positioned if this merged table is\nimmutable?\n\n> +/* returns the max update_index covered by this merged table. */\n> +uint64_t\n> +reftable_merged_table_max_update_index(struct reftable_merged_table *mt);\n> +\n> +/* returns the min update_index covered by this merged table. */\n> +uint64_t\n> +reftable_merged_table_min_update_index(struct reftable_merged_table *mt);\n> +\n> +/* releases memory for the merged_table */\n> +void reftable_merged_table_free(struct reftable_merged_table *m);\n> +\n> +/* return the hash ID of the merged table. */\n> +uint32_t reftable_merged_table_hash_id(struct reftable_merged_table *m);\n\nOK - makes sense.\n\n> +/****************************************************************\n> + Generic tables\n> +\n> + A unified API for reading tables, either merged tables, or single readers.\n> + ****************************************************************/\n\nAgain, we could just use the merged table API.\n\n[snip]\n\n> +/* convenience function to read a single ref. Returns < 0 for error, 0\n> +int reftable_table_read_ref(struct reftable_table *tab, const char *name,\n> +\t\t\t struct reftable_ref_record *ref);\n\nI presume this returns the most up-to-date record in the (possibly\nmerged) table? So we can just read the hash off the record to know what\nthis ref points to.\n\n> +/****************************************************************\n> + Mutable ref database\n> +\n> + The stack presents an interface to a mutable sequence of reftables.\n> + ****************************************************************/\n\nSo I would expect ref mutations to be done by opening the existing\nreftables as a merged table, open a reftable writer, write all the\nchanges that need to be written, and update the tables.list file...\n\n> +/* a stack is a stack of reftables, which can be mutated by pushing a table to\n> + * the top of the stack */\n> +struct reftable_stack;\n> +\n> +/* open a new reftable stack. The tables along with the table list will be\n> + stored in 'dir'. Typically, this should be .git/reftables.\n> +*/\n> +int reftable_new_stack(struct reftable_stack **dest, const char *dir,\n> +\t\t struct reftable_write_options config);\n> +\n> +/* returns the update_index at which a next table should be written. */\n> +uint64_t reftable_stack_next_update_index(struct reftable_stack *st);\n\n...so I don't see why we need a stack.\n\n> +/* holds a transaction to add tables at the top of a stack. */\n> +\n> +/*\n> + returns a new transaction to add reftables to the given stack. As a side\n> + effect, the ref database is locked.\n> +*/\n> +\t\t\t\tstruct reftable_stack *st);\n> +\n> +/* Adds a reftable to transaction. */\n> +\t\t\t int (*write_table)(struct reftable_writer *wr,\n> +\t\t\t\t\t void *arg),\n> +\t\t\t void *arg);\n> +\n> +/* Commits the transaction, releasing the lock. */\n> +\n> +/* Release all non-committed data from the transaction, and deallocate the\n> + transaction. Releases the lock if held. */\n\nWe do need a transaction to write the new tables.list and then\natomically update the repository with it, but I don't think we need one\njust to add a reftable to the stack.\n\n[snip rest of stack functions]\n\n> +/* Policy for expiring reflog entries. */\n> +struct reftable_log_expiry_config {\n> +\t/* Drop entries older than this timestamp */\n> +\tuint64_t time;\n> +\n> +\t/* Drop older entries */\n> +\tuint64_t min_update_index;\n> +};\n> +\n> +/* compacts all reftables into a giant table. Expire reflog entries if config is\n> + * non-NULL */\n> +int reftable_stack_compact_all(struct reftable_stack *st,\n> +\t\t\t struct reftable_log_expiry_config *config);\n\nAh, the stack is used for compacting as well. I don't think compacting\nbelongs here though - it should be its own thing that can make use of\nthe merged-table reader and the single-table writer.\n\n[snip]\n\n> +/* convenience function to read a single ref. Returns < 0 for error, 0\n> +int reftable_stack_read_ref(struct reftable_stack *st, const char *refname,\n> +\t\t\t struct reftable_ref_record *ref);\n> +\n> +/* convenience function to read a single log. Returns < 0 for error, 0\n> +int reftable_stack_read_log(struct reftable_stack *st, const char *refname,\n> +\t\t\t struct reftable_log_record *log);\n\nOther things that belong to the merged table reader instead of the\nstack.\n\nSome things that I think are missing:\n\n- foreach all latest record of all refs (in any order) (I see some\nfunctions above that can set the position of the iterator, but I\ndon't think that the iterator skips over irrelevant refs? So we can't\nuse it for iterating over all refs if we don't care about the history\nof refs)\n- foreach all log entries of one ref (or all refs)\n\nIn summary, I would have expected a mechanism to read multiple (possibly\none) reftable and perform queries on it, a mechanism to write a single\nreftable, and some functions to update tables.list.\n\n• ```* Re: [PATCH v2 02/13] reftable: define the public API\n2020-10-08 1:41 ` Jonathan Tan\n@ 2020-10-10 16:57 ` Han-Wen Nienhuys\n0 siblings, 0 replies; 251+ messages in thread\nFrom: Han-Wen Nienhuys @ 2020-10-10 16:57 UTC (permalink / raw)\nTo: Jonathan Tan; +Cc: Han-Wen Nienhuys via GitGitGadget, git, Jeff King\n\nHi Jonathan,\n\nthanks for a detailed look at the API. I'm replying to some queries\nhere, but I won't have time for another 2 weeks to revisit the code.\n\nOn Thu, Oct 8, 2020 at 3:41 AM Jonathan Tan <[email protected]> wrote:\n> A typical user would just want to do refname->hash, refname->log, or possibly\n> hash->refname lookups, so a ref record would be meant for low-level\n\nYou are forgetting refname -> symref target and refname -> peeled tag.\n\n> users. I can't think of a typical use case, but even if such existed, I\n> wouldn't expect this API - in particular, the refname is not written as\n> such on disk (it is composed from a prefix and a suffix, if I remember\n> correctly), so I would expect a function that one can call to write the\n> refname, but not for it to appear in a data structure.\n\nIt works with records, because it is more practical for the low level\ncode, but also because it obviates defining many functions for the\ndifferent types of lookups and seeks.\n\n> > +/* returns whether 'ref' represents a deletion */\n> > +int reftable_ref_record_is_deletion(const struct reftable_ref_record *ref);\n>\n> This looks unorthogonal - looking at the spec, the \"value type\" can\n> represent a deletion, one object name (value of the ref), two object\n> names (value of the ref + peeled target), or symbolic reference. If\n> we're willing to allocate memory for a ref record, I think we can afford\n> the extra 4 bytes (maybe 8) and use a tagged union instead.\n\nI guess you want something like\n\nstruct {\nenum TYPE { REF_DEL, REF_1VAL, REF_2VAL, REF_SYM } record_type;\nchar *ref_name;\nuint64_t update_index;\nunion {\nuint_8 *val1;\nstruct { uint8_t *val1, *val2; } val2;\nchar *sym;\n};\n};\n\nI suspect it makes initialization more verbose, but yes, I could do that.\n\n> > +/* returns whether two reftable_ref_records are the same */\n> > +int reftable_ref_record_equal(struct reftable_ref_record *a,\n> > + struct reftable_ref_record *b, int hash_size);\n>\n> Not sure what this will be used for.\n\nThis is useful for testing.\n\n> > +/* Set the range of update indices for the records we will add. When\n> > + writing a table into a stack, the min should be at least\n> > + reftable_stack_next_update_index(), or REFTABLE_API_ERROR is returned.\n> > +\n> > + For transactional updates, typically min==max. When converting an existing\n> > + ref database into a single reftable, this would be a range of update-index\n> > + timestamps.\n> > + */\n> > +void reftable_writer_set_limits(struct reftable_writer *w, uint64_t min,\n> > + uint64_t max);\n>\n> This seems to be here because we want to write the file in a single\n> pass, and the update index maximum and minimum appear in the header. If\n> we were allowed to seek while writing, could the update index maximum\n> and minimum be deduced instead?\n\nNo. The ref record update_index is delta encoded against the min\nupdate_index, so you have to know it upfront.\n\nIf I could redesign the format, I'd leave out the max update_index\nfrom the header (because it can be determined afterwards.), but it's\ntoo late now.\n\n>\n> > +/* adds a reftable_ref_record. Must be called in ascending\n> > + order. The update_index must be within the limits set by\n> > + reftable_writer_set_limits(), or REFTABLE_API_ERROR is returned.\n> > +\n> > + It is an error to write a ref record after a log record.\n> > + */\n> > +int reftable_writer_add_ref(struct reftable_writer *w,\n> > + struct reftable_ref_record *ref);\n> > +\n> > +/* Convenience function to add multiple refs. Will sort the refs by\n> > + name before adding. */\n> > +int reftable_writer_add_refs(struct reftable_writer *w,\n> > + struct reftable_ref_record *refs, int n);\n>\n> Since refs is an array of objects and not an array of pointers, these\n> two functions could be combined - the first is the same as calling the\n> second with n=1.\n>\n> Also, ascending order of what?\n\nOf record keys, ie. refname in case of ref records.\n\n> The user will also need to know where to get the update index from - I\n> presume that this will be the maximum update index of any record with\n> the given refname + 1.\n\nthere is a reftable_stack_next_update_index() for that.\n\n> > +/* reads the next reftable_ref_record. Returns < 0 for error, 0 for OK and > 0:\n> > + end of iteration.\n> > +*/\n> > +int reftable_iterator_next_ref(struct reftable_iterator *it,\n> > + struct reftable_ref_record *ref);\n> > +\n> > +/* reads the next reftable_log_record. Returns < 0 for error, 0 for OK and > 0:\n> > + end of iteration.\n> > +*/\n> > +int reftable_iterator_next_log(struct reftable_iterator *it,\n> > + struct reftable_log_record *log);\n>\n> From my recollection, in Git, we typically use foreach functions with a\n> callback that is invoked once for each result. I think that's preferable\n> to this approach.\n\nindividual entries (read_raw_ref) and iteration. It's also a natural\nstructure, because internally the iteration state has to be stored\n(iterating merged tables stores the iterators in a priority queue.)\n\n> [snip]\n>\n> > +/****************************************************************\n> > + Merged tables\n> > +\n> > + A ref database kept in a sequence of table files. The merged_table presents a\n> > + unified view to reading (seeking, iterating) a sequence of immutable tables.\n> > + ****************************************************************/\n> > +\n> > +/* A merged table is implements seeking/iterating over a stack of tables. */\n> > +struct reftable_merged_table;\n> > +\n> > +/* A generic reftable; see below. */\n> > +struct reftable_table;\n>\n> Why would we need to see an individual reftable?\n\nIt could be useful diagnostics and troubleshooting. For example, if\nyou are debugging or trying to troubleshoot/fsck a repo, it might be\ninteresting to read a single file from .git/reftable/\n\nPhilosophically, since we have to expose the functionality to write a\nsingle table, it seems reasonable to read single tables for symmetry\nas well.\n\n> Could we just represent\n> a merged table as a virtual concatenation of blocks (as if all the\n> blocks were in the same file)?\n\nNo. The format doesn't work like that.\n\n> > +/* reftable_new_merged_table creates a new merged table. It takes ownership of\n> > + the stack array.\n> > +*/\n> > +int reftable_new_merged_table(struct reftable_merged_table **dest,\n> > + struct reftable_table *stack, int n,\n> > + uint32_t hash_id);\n>\n> I presume this would be used for things like compacting a few reftables\n> together? In which case, I would expect this function to just take a\n> list of filenames.\n\nThe merging of tables has nothing to do with the filesystem, and could\nbe done with reftables represented as in memory structure. This is\nalso how the unittests work.\n\n> > +/* returns an iterator positioned just before 'name' */\n> > +int reftable_merged_table_seek_ref(struct reftable_merged_table *mt,\n> > + struct reftable_iterator *it,\n> > + const char *name);\n> > +\n> > +/* returns an iterator for log entry, at given update_index */\n> > +int reftable_merged_table_seek_log_at(struct reftable_merged_table *mt,\n> > + struct reftable_iterator *it,\n> > + const char *name, uint64_t update_index);\n> > +\n> > +/* like reftable_merged_table_seek_log_at but look for the newest entry. */\n> > +int reftable_merged_table_seek_log(struct reftable_merged_table *mt,\n> > + struct reftable_iterator *it,\n> > + const char *name);\n>\n> Why do iterators need to be precisely positioned if this merged table is\n> immutable?\n\nI don't understand the question. How would you read a single ref from\na merged table without a seek function?\n\n> > +/* convenience function to read a single ref. Returns < 0 for error, 0\n> > + for success, and 1 if ref not found. */\n> > +int reftable_table_read_ref(struct reftable_table *tab, const char *name,\n> > + struct reftable_ref_record *ref);\n>\n> I presume this returns the most up-to-date record in the (possibly\n> merged) table? So we can just read the hash off the record to know what\n> this ref points to.\n\ncorrect.\n\n> > +/****************************************************************\n> > + Mutable ref database\n> > +\n> > + The stack presents an interface to a mutable sequence of reftables.\n> > + ****************************************************************/\n>\n> So I would expect ref mutations to be done by opening the existing\n> reftables as a merged table, open a reftable writer, write all the\n> changes that need to be written, and update the tables.list file...\n\nRoughly, yes, but there are other considerations: you have to check\ncompaction may have deleted some of the tables referenced, so you have\nto retry). If there are any failures, the transaction fails and you\nhave to clean up already written tables. If the write succeeds, but\nthe stack becomes unbalanced, you have to do a compaction. If you have\nto reload data, you want to avoid closing and opening the same file.\n\nIf you are curious what the stack does, have a look at stack.c.\n\nAlso, this is for separation of logic. The merged table is composed of\nreftables that have no particular type of storage, but support the\nread interface. The stack is what ties the merged table to a\nposix-like file system, and provides mutations.\n\n> > +/* holds a transaction to add tables at the top of a stack. */\n> > +\n> > +/*\n> > + returns a new transaction to add reftables to the given stack. As a side\n> > + effect, the ref database is locked.\n> > +*/\n> > + struct reftable_stack *st);\n> > +\n> > +/* Adds a reftable to transaction. */\n> > + int (*write_table)(struct reftable_writer *wr,\n> > + void *arg),\n> > + void *arg);\n> > +\n> > +/* Commits the transaction, releasing the lock. */\n> > +\n> > +/* Release all non-committed data from the transaction, and deallocate the\n> > + transaction. Releases the lock if held. */\n>\n> We do need a transaction to write the new tables.list and then\n> atomically update the repository with it, but I don't think we need one\n> just to add a reftable to the stack.\n\nsee above.\n\n> > +/* compacts all reftables into a giant table. Expire reflog entries if config is\n> > + * non-NULL */\n> > +int reftable_stack_compact_all(struct reftable_stack *st,\n> > + struct reftable_log_expiry_config *config);\n>\n> Ah, the stack is used for compacting as well. I don't think compacting\n> belongs here though - it should be its own thing that can make use of\n> the merged-table reader and the single-table writer.\n\nWhy should it be like that, and where should compaction live?\n\n> Some things that I think are missing:\n>\n> - foreach all latest record of all refs (in any order) (I see some\n\nRef records are keyed by name, so the iteration produces each ref only once.\n\n> functions above that can set the position of the iterator, but I\n> don't think that the iterator skips over irrelevant refs?\n\nWhat makes you think that?\n\n> So we can't\n> use it for iterating over all refs if we don't care about the history\n> of refs)\n\nI think you might be confusing the refs with reflogs here. The history\nof a ref is kept in the reflog. This is why functions that want to\nseek to a log record need an update_index timestamp.\n\n> - foreach all log entries of one ref (or all refs)\n\nBefore reviewing the API header here, I think it might be useful to\nalso look at the commit in the other series that uses the API to\nimplement the git ref backend. It shows how the foreach functions can\nbe implemented using the iterator interface.\n\n> In summary, I would have expected a mechanism to read multiple (possibly\n> one) reftable and perform queries on it, a mechanism to write a single\n> reftable, and some functions to update tables.list.\n\nI understand your expectation, but I think that expectation glosses\nover important details of how it actually works.\n\n--\nI work 80%. Don't expect answers from me on Fridays.\n--\nGoogle Germany GmbH, Erika-Mann-Strasse 33, 80636 Munich\nRegistergericht und -nummer: Hamburg, HRB 86891\nSitz der Gesellschaft: Hamburg\nGeschäftsführer: Paul Manicle, Halimah DeLaine Prado\n\n• ```* [PATCH v2 03/13] vcxproj: adjust for the reftable changes\n2020-10-01 16:10 ` [PATCH v2 00/13] reftable library Han-Wen Nienhuys via GitGitGadget\n2020-10-01 16:10 ` [PATCH v2 02/13] reftable: define the public API Han-Wen Nienhuys via GitGitGadget\n@ 2020-10-01 16:10 ` Johannes Schindelin via GitGitGadget\n2020-10-02 4:02 ` Jonathan Nieder\n2020-10-01 16:10 ` [PATCH v2 04/13] reftable: add a barebones unittest framework Han-Wen Nienhuys via GitGitGadget\n` (10 subsequent siblings)\nFrom: Johannes Schindelin via GitGitGadget @ 2020-10-01 16:10 UTC (permalink / raw)\nTo: git; +Cc: Han-Wen Nienhuys, Jeff King, Han-Wen Nienhuys, Johannes Schindelin\n\nFrom: Johannes Schindelin <[email protected]>\n\nThis allows Git to be compiled via Visual Studio again after integrating\nthe `hn/reftable` branch.\n\nSigned-off-by: Johannes Schindelin <[email protected]>\n---\nconfig.mak.uname | 2 +-\ncontrib/buildsystems/Generators/Vcxproj.pm | 11 ++++++++++-\n2 files changed, 11 insertions(+), 2 deletions(-)\n\ndiff --git a/config.mak.uname b/config.mak.uname\nindex c7eba69e54..ae4e25a1a4 100644\n--- a/config.mak.uname\n+++ b/config.mak.uname\n@@ -709,7 +709,7 @@ vcxproj:\n# Make .vcxproj files and add them\nunset QUIET_GEN QUIET_BUILT_IN; \\\nperl contrib/buildsystems/generate -g Vcxproj\n-\tgit add -f git.sln {*,*/lib,t/helper/*}/*.vcxproj\n+\tgit add -f git.sln {*,*/lib,*/libreftable,t/helper/*}/*.vcxproj\n\n(echo '<Project xmlns=\"http://schemas.microsoft.com/developer/msbuild/2003\">' && \\\ndiff --git a/contrib/buildsystems/Generators/Vcxproj.pm b/contrib/buildsystems/Generators/Vcxproj.pm\nindex d2584450ba..1a25789d28 100644\n--- a/contrib/buildsystems/Generators/Vcxproj.pm\n+++ b/contrib/buildsystems/Generators/Vcxproj.pm\n@@ -77,7 +77,7 @@ sub createProject {\nmy \\$libs_release = \"\\n \";\nmy \\$libs_debug = \"\\n \";\nif (!\\$static_library) {\n- \\$libs_release = join(\";\", sort(grep /^(?!libgit\\.lib|xdiff\\/lib\\.lib|vcs-svn\\/lib\\.lib)/, @{\\$\\$build_structure{\"\\$prefix\\${name}_LIBS\"}}));\n+ \\$libs_release = join(\";\", sort(grep /^(?!libgit\\.lib|xdiff\\/lib\\.lib|vcs-svn\\/lib\\.lib|reftable\\/libreftable\\.lib)/, @{\\$\\$build_structure{\"\\$prefix\\${name}_LIBS\"}}));\n\\$libs_debug = \\$libs_release;\n\\$libs_debug =~ s/zlib\\.lib/zlibd\\.lib/g;\n\\$libs_debug =~ s/libexpat\\.lib/libexpatd\\.lib/g;\n@@ -232,6 +232,7 @@ sub createProject {\nEOM\nif (!\\$static_library || \\$target =~ 'vcs-svn' || \\$target =~ 'xdiff') {\nmy \\$uuid_libgit = \\$\\$build_structure{\"LIBS_libgit_GUID\"};\n+ my \\$uuid_libreftable = \\$\\$build_structure{\"LIBS_reftable/libreftable_GUID\"};\nmy \\$uuid_xdiff_lib = \\$\\$build_structure{\"LIBS_xdiff/lib_GUID\"};\n\nprint F << \"EOM\";\n@@ -241,6 +242,14 @@ sub createProject {\n<ReferenceOutputAssembly>false</ReferenceOutputAssembly>\n</ProjectReference>\nEOM\n+ if (!(\\$name =~ /xdiff|libreftable/)) {\n+ print F << \"EOM\";\n+ <ProjectReference Include=\"\\$cdup\\\\reftable\\\\libreftable\\\\libreftable.vcxproj\">\n+ <Project>\\$uuid_libreftable</Project>\n+ <ReferenceOutputAssembly>false</ReferenceOutputAssembly>\n+ </ProjectReference>\n+EOM\n+ }\nif (!(\\$name =~ 'xdiff')) {\nprint F << \"EOM\";\n<ProjectReference Include=\"\\$cdup\\\\xdiff\\\\lib\\\\xdiff_lib.vcxproj\">\n--\n\n• ```* Re: [PATCH v2 03/13] vcxproj: adjust for the reftable changes\n2020-10-01 16:10 ` [PATCH v2 03/13] vcxproj: adjust for the reftable changes Johannes Schindelin via GitGitGadget\n@ 2020-10-02 4:02 ` Jonathan Nieder\n2020-10-02 11:43 ` Johannes Schindelin\nFrom: Jonathan Nieder @ 2020-10-02 4:02 UTC (permalink / raw)\nCc: git, Han-Wen Nienhuys, Jeff King, Han-Wen Nienhuys, Johannes Schindelin\n\nHan-Wen Nienhuys wrote:\n\n> From: Johannes Schindelin <[email protected]>\n>\n> This allows Git to be compiled via Visual Studio again after integrating\n> the `hn/reftable` branch.\n\nnit: This branch name is no longer meaningful to the primary audience\nfor the commit message (people discovering this commit in git history\nlater).\n\n> Signed-off-by: Johannes Schindelin <[email protected]>\n> ---\n> config.mak.uname | 2 +-\n> contrib/buildsystems/Generators/Vcxproj.pm | 11 ++++++++++-\n> 2 files changed, 11 insertions(+), 2 deletions(-)\n\nCan this be squashed into or put immediately after patch 5 which\nintroduces the Makefile?\n\nThanks,\nJonathan\n\n• ```* Re: [PATCH v2 03/13] vcxproj: adjust for the reftable changes\n2020-10-02 4:02 ` Jonathan Nieder\n@ 2020-10-02 11:43 ` Johannes Schindelin\n0 siblings, 0 replies; 251+ messages in thread\nFrom: Johannes Schindelin @ 2020-10-02 11:43 UTC (permalink / raw)\nTo: Jonathan Nieder\nCc: Johannes Schindelin via GitGitGadget, git, Han-Wen Nienhuys,\nJeff King, Han-Wen Nienhuys\n\nHi Jonathan,\n\nOn Thu, 1 Oct 2020, Jonathan Nieder wrote:\n\n> Han-Wen Nienhuys wrote:\n>\n> > From: Johannes Schindelin <[email protected]>\n> >\n> > This allows Git to be compiled via Visual Studio again after integrating\n> > the `hn/reftable` branch.\n>\n> nit: This branch name is no longer meaningful to the primary audience\n> for the commit message (people discovering this commit in git history\n> later).\n>\n> > Signed-off-by: Johannes Schindelin <[email protected]>\n> > ---\n> > config.mak.uname | 2 +-\n> > contrib/buildsystems/Generators/Vcxproj.pm | 11 ++++++++++-\n> > 2 files changed, 11 insertions(+), 2 deletions(-)\n>\n> Can this be squashed into or put immediately after patch 5 which\n> introduces the Makefile?\n\nI never intended this to be a stand-alone patch. So yes, I would be very\nmuch in favor of squashing these changes into the appropriate commit.\n\nCiao,\nDscho\n\n• ```* [PATCH v2 04/13] reftable: add a barebones unittest framework\n2020-10-01 16:10 ` [PATCH v2 00/13] reftable library Han-Wen Nienhuys via GitGitGadget\n` (2 preceding siblings ...)\n2020-10-01 16:10 ` [PATCH v2 03/13] vcxproj: adjust for the reftable changes Johannes Schindelin via GitGitGadget\n@ 2020-10-01 16:10 ` Han-Wen Nienhuys via GitGitGadget\n2020-10-02 4:05 ` Jonathan Nieder\n2020-10-08 1:45 ` Jonathan Tan\n2020-10-01 16:10 ` [PATCH v2 05/13] reftable: utility functions Han-Wen Nienhuys via GitGitGadget\n` (9 subsequent siblings)\n13 siblings, 2 replies; 251+ messages in thread\nFrom: Han-Wen Nienhuys via GitGitGadget @ 2020-10-01 16:10 UTC (permalink / raw)\nTo: git; +Cc: Han-Wen Nienhuys, Jeff King, Han-Wen Nienhuys, Han-Wen Nienhuys\n\n---\nreftable/test_framework.c | 68 +++++++++++++++++++++++++++++++++++++++\nreftable/test_framework.h | 59 +++++++++++++++++++++++++++++++++\n2 files changed, 127 insertions(+)\ncreate mode 100644 reftable/test_framework.c\ncreate mode 100644 reftable/test_framework.h\n\ndiff --git a/reftable/test_framework.c b/reftable/test_framework.c\nnew file mode 100644\nindex 0000000000..8d718f2f06\n--- /dev/null\n+++ b/reftable/test_framework.c\n@@ -0,0 +1,68 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"test_framework.h\"\n+\n+#include \"system.h\"\n+#include \"basics.h\"\n+\n+static struct test_case **test_cases;\n+static int test_case_len;\n+static int test_case_cap;\n+\n+static struct test_case *new_test_case(const char *name, void (*testfunc)(void))\n+{\n+\tstruct test_case *tc = reftable_malloc(sizeof(struct test_case));\n+\ttc->name = name;\n+\ttc->testfunc = testfunc;\n+\treturn tc;\n+}\n+\n+struct test_case *add_test_case(const char *name, void (*testfunc)(void))\n+{\n+\tstruct test_case *tc = new_test_case(name, testfunc);\n+\tif (test_case_len == test_case_cap) {\n+\t\ttest_case_cap = 2 * test_case_cap + 1;\n+\t\ttest_cases = reftable_realloc(\n+\t\t\ttest_cases, sizeof(struct test_case) * test_case_cap);\n+\t}\n+\n+\ttest_cases[test_case_len++] = tc;\n+\treturn tc;\n+}\n+\n+int test_main(int argc, const char *argv[])\n+{\n+\tconst char *filter = NULL;\n+\tint i = 0;\n+\tif (argc > 1) {\n+\t\tfilter = argv;\n+\t}\n+\n+\tfor (i = 0; i < test_case_len; i++) {\n+\t\tconst char *name = test_cases[i]->name;\n+\t\tif (filter == NULL || strstr(name, filter) != NULL) {\n+\t\t\tprintf(\"case %s\\n\", name);\n+\t\t\ttest_cases[i]->testfunc();\n+\t\t} else {\n+\t\t\tprintf(\"skip %s\\n\", name);\n+\t\t}\n+\n+\t\treftable_free(test_cases[i]);\n+\t}\n+\treftable_free(test_cases);\n+\ttest_cases = NULL;\n+\ttest_case_len = 0;\n+\ttest_case_cap = 0;\n+\treturn 0;\n+}\n+\n+void set_test_hash(uint8_t *p, int i)\n+{\n+\tmemset(p, (uint8_t)i, hash_size(SHA1_ID));\n+}\ndiff --git a/reftable/test_framework.h b/reftable/test_framework.h\nnew file mode 100644\nindex 0000000000..f0a208e880\n--- /dev/null\n+++ b/reftable/test_framework.h\n@@ -0,0 +1,59 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#ifndef TEST_FRAMEWORK_H\n+#define TEST_FRAMEWORK_H\n+\n+#include \"system.h\"\n+\n+#ifdef NDEBUG\n+#undef NDEBUG\n+#endif\n+\n+#ifdef assert\n+#undef assert\n+#endif\n+\n+#define assert_err(c) \\\n+\tif (c != 0) { \\\n+\t\tfflush(stderr); \\\n+\t\tfflush(stdout); \\\n+\t\tfprintf(stderr, \"%s: %d: error == %d (%s), want 0\\n\", \\\n+\t\t\t__FILE__, __LINE__, c, reftable_error_str(c)); \\\n+\t\tabort(); \\\n+\t}\n+\n+#define assert_streq(a, b) \\\n+\tif (strcmp(a, b)) { \\\n+\t\tfflush(stderr); \\\n+\t\tfflush(stdout); \\\n+\t\tfprintf(stderr, \"%s:%d: %s (%s) != %s (%s)\\n\", __FILE__, \\\n+\t\t\t__LINE__, #a, a, #b, b); \\\n+\t\tabort(); \\\n+\t}\n+\n+#define assert(c) \\\n+\tif (!(c)) { \\\n+\t\tfflush(stderr); \\\n+\t\tfflush(stdout); \\\n+\t\tfprintf(stderr, \"%s: %d: failed assertion %s\\n\", __FILE__, \\\n+\t\t\t__LINE__, #c); \\\n+\t\tabort(); \\\n+\t}\n+\n+struct test_case {\n+\tconst char *name;\n+\tvoid (*testfunc)(void);\n+};\n+\n+struct test_case *add_test_case(const char *name, void (*testfunc)(void));\n+int test_main(int argc, const char *argv[]);\n+\n+void set_test_hash(uint8_t *p, int i);\n+\n+#endif\n--\n\n• ```* Re: [PATCH v2 04/13] reftable: add a barebones unittest framework\n2020-10-01 16:10 ` [PATCH v2 04/13] reftable: add a barebones unittest framework Han-Wen Nienhuys via GitGitGadget\n@ 2020-10-02 4:05 ` Jonathan Nieder\n2020-10-08 1:45 ` Jonathan Tan\n1 sibling, 0 replies; 251+ messages in thread\nFrom: Jonathan Nieder @ 2020-10-02 4:05 UTC (permalink / raw)\nCc: git, Han-Wen Nienhuys, Jeff King, Han-Wen Nienhuys\n\nHi,\n\nHan-Wen Nienhuys wrote:\n\n> ---\n> reftable/test_framework.c | 68 +++++++++++++++++++++++++++++++++++++++\n> reftable/test_framework.h | 59 +++++++++++++++++++++++++++++++++\n> 2 files changed, 127 insertions(+)\n> create mode 100644 reftable/test_framework.c\n> create mode 100644 reftable/test_framework.h\n\nHm, can the commit message say a little about the motivation for this\ntest framework and what it allows?\n\nFor example, does it allow unit tests to write output in TAP format?\nHow does it compare to existing frameworks like\nhttps://www.eyrie.org/~eagle/software/c-tap-harness/? How does this\napproach compare to what Git's existing unit-style tests with helpers\nin t/helper/ driven by scripts in t/ do?\n\nThanks,\nJonathan\n\n• ```* Re: [PATCH v2 04/13] reftable: add a barebones unittest framework\n2020-10-01 16:10 ` [PATCH v2 04/13] reftable: add a barebones unittest framework Han-Wen Nienhuys via GitGitGadget\n2020-10-02 4:05 ` Jonathan Nieder\n@ 2020-10-08 1:45 ` Jonathan Tan\nFrom: Jonathan Tan @ 2020-10-08 1:45 UTC (permalink / raw)\nTo: gitgitgadget; +Cc: git, hanwen, peff, hanwenn, Jonathan Tan\n\n>\n> ---\n> reftable/test_framework.c | 68 +++++++++++++++++++++++++++++++++++++++\n> reftable/test_framework.h | 59 +++++++++++++++++++++++++++++++++\n\nEven if reftable will be a project maintained by the Git project but\nindependent enough to be used by other projects, I don't think it's\nworth creating a separate test framework. E.g. as far as I can tell,\nwhen we import sha1dc, we don't import any tests, so I don't think they\nneed to import tests either - they can run the tests in the Git repo\nthemselves if they need to.\n\n• ```* Re: [PATCH v2 04/13] reftable: add a barebones unittest framework\n2020-10-08 1:45 ` Jonathan Tan\n@ 2020-10-08 22:31 ` Josh Steadmon\n0 siblings, 0 replies; 251+ messages in thread\nTo: Jonathan Tan; +Cc: gitgitgadget, git, hanwen, peff, hanwenn\n\nOn 2020.10.07 18:45, Jonathan Tan wrote:\n> > From: Han-Wen Nienhuys <[email protected]>\n> >\n> > Signed-off-by: Han-Wen Nienhuys <[email protected]>\n> > ---\n> > reftable/test_framework.c | 68 +++++++++++++++++++++++++++++++++++++++\n> > reftable/test_framework.h | 59 +++++++++++++++++++++++++++++++++\n>\n> Even if reftable will be a project maintained by the Git project but\n> independent enough to be used by other projects, I don't think it's\n> worth creating a separate test framework. E.g. as far as I can tell,\n> when we import sha1dc, we don't import any tests, so I don't think they\n> need to import tests either - they can run the tests in the Git repo\n> themselves if they need to.\n\nI agree with Jonathan here, I think we should stick with the existing\ntest framework.\n\n• ```* [PATCH v2 05/13] reftable: utility functions\n2020-10-01 16:10 ` [PATCH v2 00/13] reftable library Han-Wen Nienhuys via GitGitGadget\n` (3 preceding siblings ...)\n2020-10-01 16:10 ` [PATCH v2 04/13] reftable: add a barebones unittest framework Han-Wen Nienhuys via GitGitGadget\n@ 2020-10-01 16:10 ` Han-Wen Nienhuys via GitGitGadget\n2020-10-02 4:12 ` Jonathan Nieder\n` (2 more replies)\n2020-10-01 16:10 ` [PATCH v2 06/13] reftable: (de)serialization for the polymorphic record type Han-Wen Nienhuys via GitGitGadget\n` (8 subsequent siblings)\n13 siblings, 3 replies; 251+ messages in thread\nFrom: Han-Wen Nienhuys via GitGitGadget @ 2020-10-01 16:10 UTC (permalink / raw)\nTo: git; +Cc: Han-Wen Nienhuys, Jeff King, Han-Wen Nienhuys, Han-Wen Nienhuys\n\nThis commit provides basic utility classes for the reftable library.\n\nSince the reftable library must compile standalone, there may be some overlap\nwith git-core utility functions.\n\n---\nMakefile | 26 ++++++-\nreftable/basics.c | 131 +++++++++++++++++++++++++++++++++\nreftable/basics.h | 48 +++++++++++++\nreftable/blocksource.c | 148 ++++++++++++++++++++++++++++++++++++++\nreftable/blocksource.h | 22 ++++++\nreftable/compat.c | 110 ++++++++++++++++++++++++++++\nreftable/compat.h | 48 +++++++++++++\nreftable/publicbasics.c | 100 ++++++++++++++++++++++++++\nreftable/reftable-tests.h | 22 ++++++\nreftable/strbuf.c | 142 ++++++++++++++++++++++++++++++++++++\nreftable/strbuf.h | 80 +++++++++++++++++++++\nreftable/strbuf_test.c | 37 ++++++++++\nreftable/system.h | 51 +++++++++++++\nt/helper/test-reftable.c | 8 +++\nt/helper/test-tool.c | 1 +\nt/helper/test-tool.h | 1 +\n16 files changed, 972 insertions(+), 3 deletions(-)\ncreate mode 100644 reftable/basics.c\ncreate mode 100644 reftable/basics.h\ncreate mode 100644 reftable/blocksource.c\ncreate mode 100644 reftable/blocksource.h\ncreate mode 100644 reftable/compat.c\ncreate mode 100644 reftable/compat.h\ncreate mode 100644 reftable/publicbasics.c\ncreate mode 100644 reftable/reftable-tests.h\ncreate mode 100644 reftable/strbuf.c\ncreate mode 100644 reftable/strbuf.h\ncreate mode 100644 reftable/strbuf_test.c\ncreate mode 100644 reftable/system.h\ncreate mode 100644 t/helper/test-reftable.c\n\ndiff --git a/Makefile b/Makefile\nindex de53954590..e40d55cd87 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -727,6 +727,7 @@ TEST_BUILTINS_OBJS += test-read-cache.o\nTEST_BUILTINS_OBJS += test-ref-store.o\n+TEST_BUILTINS_OBJS += test-reftable.o\nTEST_BUILTINS_OBJS += test-regex.o\nTEST_BUILTINS_OBJS += test-repository.o\nTEST_BUILTINS_OBJS += test-revision-walking.o\n@@ -806,6 +807,8 @@ TEST_SHELL_PATH = \\$(SHELL_PATH)\n\nLIB_FILE = libgit.a\nXDIFF_LIB = xdiff/lib.a\n+REFTABLE_LIB = reftable/libreftable.a\n+REFTABLE_TEST_LIB = reftable/libreftable_test.a\n\nGENERATED_H += config-list.h\nGENERATED_H += command-list.h\n@@ -1167,7 +1170,7 @@ THIRD_PARTY_SOURCES += compat/regex/%\nTHIRD_PARTY_SOURCES += sha1collisiondetection/%\nTHIRD_PARTY_SOURCES += sha1dc/%\n\n-GITLIBS = common-main.o \\$(LIB_FILE) \\$(XDIFF_LIB)\n+GITLIBS = common-main.o \\$(LIB_FILE) \\$(XDIFF_LIB) \\$(REFTABLE_LIB)\nEXTLIBS =\n\nGIT_USER_AGENT = git/\\$(GIT_VERSION)\n@@ -2369,10 +2372,21 @@ XDIFF_OBJS += xdiff/xpatience.o\nXDIFF_OBJS += xdiff/xprepare.o\nXDIFF_OBJS += xdiff/xutils.o\n\n+REFTABLE_OBJS += reftable/basics.o\n+REFTABLE_OBJS += reftable/blocksource.o\n+REFTABLE_OBJS += reftable/publicbasics.o\n+REFTABLE_OBJS += reftable/compat.o\n+REFTABLE_OBJS += reftable/strbuf.o\n+\n+REFTABLE_TEST_OBJS += reftable/strbuf_test.o\n+REFTABLE_TEST_OBJS += reftable/test_framework.o\n+\nTEST_OBJS := \\$(patsubst %\\$X,%.o,\\$(TEST_PROGRAMS)) \\$(patsubst %,t/helper/%,\\$(TEST_BUILTINS_OBJS))\nOBJECTS := \\$(LIB_OBJS) \\$(BUILTIN_OBJS) \\$(PROGRAM_OBJS) \\$(TEST_OBJS) \\\n\\$(XDIFF_OBJS) \\\n\\$(FUZZ_OBJS) \\\n+\t\\$(REFTABLE_OBJS) \\\n+\t\\$(REFTABLE_TEST_OBJS) \\\ncommon-main.o \\\ngit.o\nifndef NO_CURL\n@@ -2524,6 +2538,12 @@ \\$(LIB_FILE): \\$(LIB_OBJS)\n\\$(XDIFF_LIB): \\$(XDIFF_OBJS)\n\\$(QUIET_AR)\\$(RM) \\$@ && \\$(AR) \\$(ARFLAGS) \\$@ \\$^\n\n+\\$(REFTABLE_LIB): \\$(REFTABLE_OBJS)\n+\t\\$(QUIET_AR)\\$(RM) \\$@ && \\$(AR) \\$(ARFLAGS) \\$@ \\$^\n+\n+\\$(REFTABLE_TEST_LIB): \\$(REFTABLE_TEST_OBJS)\n+\t\\$(QUIET_AR)\\$(RM) \\$@ && \\$(AR) \\$(ARFLAGS) \\$@ \\$^\n+\nexport DEFAULT_EDITOR DEFAULT_PAGER\n\nDocumentation/GIT-EXCLUDED-PROGRAMS: FORCE\n@@ -2802,7 +2822,7 @@ perf: all\n\nt/helper/test-tool\\$X: \\$(patsubst %,t/helper/%,\\$(TEST_BUILTINS_OBJS))\n\n-t/helper/test-%\\$X: t/helper/test-%.o GIT-LDFLAGS \\$(GITLIBS)\n+t/helper/test-%\\$X: t/helper/test-%.o GIT-LDFLAGS \\$(GITLIBS) \\$(REFTABLE_TEST_LIB)\n\\$(QUIET_LINK)\\$(CC) \\$(ALL_CFLAGS) -o \\$@ \\$(ALL_LDFLAGS) \\$(filter %.o,\\$^) \\$(filter %.a,\\$^) \\$(LIBS)\n\ncheck-sha1:: t/helper/test-tool\\$X\n@@ -3133,7 +3153,7 @@ cocciclean:\nclean: profile-clean coverage-clean cocciclean\n\\$(RM) *.res\n\\$(RM) \\$(OBJECTS)\n-\t\\$(RM) \\$(LIB_FILE) \\$(XDIFF_LIB)\n+\t\\$(RM) \\$(LIB_FILE) \\$(XDIFF_LIB) \\$(REFTABLE_LIB) \\$(REFTABLE_TEST_LIB)\n\\$(RM) \\$(ALL_PROGRAMS) \\$(SCRIPT_LIB) \\$(BUILT_INS) git\\$X\n\\$(RM) \\$(TEST_PROGRAMS)\n\\$(RM) \\$(FUZZ_PROGRAMS)\ndiff --git a/reftable/basics.c b/reftable/basics.c\nnew file mode 100644\nindex 0000000000..c429055d15\n--- /dev/null\n+++ b/reftable/basics.c\n@@ -0,0 +1,131 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"basics.h\"\n+\n+void put_be24(uint8_t *out, uint32_t i)\n+{\n+\tout = (uint8_t)((i >> 16) & 0xff);\n+\tout = (uint8_t)((i >> 8) & 0xff);\n+\tout = (uint8_t)(i & 0xff);\n+}\n+\n+uint32_t get_be24(uint8_t *in)\n+{\n+\treturn (uint32_t)(in) << 16 | (uint32_t)(in) << 8 |\n+\t (uint32_t)(in);\n+}\n+\n+void put_be16(uint8_t *out, uint16_t i)\n+{\n+\tout = (uint8_t)((i >> 8) & 0xff);\n+\tout = (uint8_t)(i & 0xff);\n+}\n+\n+int binsearch(size_t sz, int (*f)(size_t k, void *args), void *args)\n+{\n+\tsize_t lo = 0;\n+\tsize_t hi = sz;\n+\n+\t/* invariant: (hi == sz) || f(hi) == true\n+\t (lo == 0 && f(0) == true) || fi(lo) == false\n+\t */\n+\twhile (hi - lo > 1) {\n+\t\tsize_t mid = lo + (hi - lo) / 2;\n+\n+\t\tint val = f(mid, args);\n+\t\tif (val) {\n+\t\t\thi = mid;\n+\t\t} else {\n+\t\t\tlo = mid;\n+\t\t}\n+\t}\n+\n+\tif (lo == 0) {\n+\t\tif (f(0, args)) {\n+\t\t\treturn 0;\n+\t\t} else {\n+\t\t\treturn 1;\n+\t\t}\n+\t}\n+\n+\treturn hi;\n+}\n+\n+void free_names(char **a)\n+{\n+\tchar **p = a;\n+\tif (p == NULL) {\n+\t\treturn;\n+\t}\n+\twhile (*p) {\n+\t\treftable_free(*p);\n+\t\tp++;\n+\t}\n+\treftable_free(a);\n+}\n+\n+int names_length(char **names)\n+{\n+\tint len = 0;\n+\tchar **p = names;\n+\twhile (*p) {\n+\t\tp++;\n+\t\tlen++;\n+\t}\n+\treturn len;\n+}\n+\n+void parse_names(char *buf, int size, char ***namesp)\n+{\n+\tchar **names = NULL;\n+\tsize_t names_cap = 0;\n+\tsize_t names_len = 0;\n+\n+\tchar *p = buf;\n+\tchar *end = buf + size;\n+\twhile (p < end) {\n+\t\tchar *next = strchr(p, '\\n');\n+\t\tif (next != NULL) {\n+\t\t\t*next = 0;\n+\t\t} else {\n+\t\t\tnext = end;\n+\t\t}\n+\t\tif (p < next) {\n+\t\t\tif (names_len == names_cap) {\n+\t\t\t\tnames_cap = 2 * names_cap + 1;\n+\t\t\t\tnames = reftable_realloc(\n+\t\t\t\t\tnames, names_cap * sizeof(char *));\n+\t\t\t}\n+\t\t\tnames[names_len++] = xstrdup(p);\n+\t\t}\n+\t\tp = next + 1;\n+\t}\n+\n+\tif (names_len == names_cap) {\n+\t\tnames_cap = 2 * names_cap + 1;\n+\t\tnames = reftable_realloc(names, names_cap * sizeof(char *));\n+\t}\n+\n+\tnames[names_len] = NULL;\n+\t*namesp = names;\n+}\n+\n+int names_equal(char **a, char **b)\n+{\n+\twhile (*a && *b) {\n+\t\tif (strcmp(*a, *b)) {\n+\t\t\treturn 0;\n+\t\t}\n+\n+\t\ta++;\n+\t\tb++;\n+\t}\n+\n+\treturn *a == *b;\n+}\ndiff --git a/reftable/basics.h b/reftable/basics.h\nnew file mode 100644\nindex 0000000000..90639865a7\n--- /dev/null\n+++ b/reftable/basics.h\n@@ -0,0 +1,48 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#ifndef BASICS_H\n+#define BASICS_H\n+\n+#include \"system.h\"\n+\n+/* Bigendian en/decoding of integers */\n+\n+void put_be24(uint8_t *out, uint32_t i);\n+uint32_t get_be24(uint8_t *in);\n+void put_be16(uint8_t *out, uint16_t i);\n+\n+/*\n+ find smallest index i in [0, sz) at which f(i) is true, assuming\n+ that f is ascending. Return sz if f(i) is false for all indices.\n+*/\n+int binsearch(size_t sz, int (*f)(size_t k, void *args), void *args);\n+\n+/*\n+ Frees a NULL terminated array of malloced strings. The array itself is also\n+ freed.\n+ */\n+void free_names(char **a);\n+\n+/* parse a newline separated list of names. Empty names are discarded. */\n+void parse_names(char *buf, int size, char ***namesp);\n+\n+/* compares two NULL-terminated arrays of strings. */\n+int names_equal(char **a, char **b);\n+\n+/* returns the array size of a NULL-terminated array of strings. */\n+int names_length(char **names);\n+\n+/* Allocation routines; they invoke the functions set through\n+ * reftable_set_alloc() */\n+void *reftable_malloc(size_t sz);\n+void *reftable_realloc(void *p, size_t sz);\n+void reftable_free(void *p);\n+void *reftable_calloc(size_t sz);\n+\n+#endif\ndiff --git a/reftable/blocksource.c b/reftable/blocksource.c\nnew file mode 100644\nindex 0000000000..7f29b864f9\n--- /dev/null\n+++ b/reftable/blocksource.c\n@@ -0,0 +1,148 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"system.h\"\n+\n+#include \"basics.h\"\n+#include \"blocksource.h\"\n+#include \"strbuf.h\"\n+#include \"reftable.h\"\n+\n+static void strbuf_return_block(void *b, struct reftable_block *dest)\n+{\n+\tmemset(dest->data, 0xff, dest->len);\n+\treftable_free(dest->data);\n+}\n+\n+static void strbuf_close(void *b)\n+{\n+}\n+\n+static int strbuf_read_block(void *v, struct reftable_block *dest, uint64_t off,\n+\t\t\t uint32_t size)\n+{\n+\tstruct strbuf *b = (struct strbuf *)v;\n+\tassert(off + size <= b->len);\n+\tdest->data = reftable_calloc(size);\n+\tmemcpy(dest->data, b->buf + off, size);\n+\tdest->len = size;\n+\treturn size;\n+}\n+\n+static uint64_t strbuf_size(void *b)\n+{\n+\treturn ((struct strbuf *)b)->len;\n+}\n+\n+static struct reftable_block_source_vtable strbuf_vtable = {\n+\t.size = &strbuf_size,\n+\t.return_block = &strbuf_return_block,\n+\t.close = &strbuf_close,\n+};\n+\n+void block_source_from_strbuf(struct reftable_block_source *bs,\n+\t\t\t struct strbuf *buf)\n+{\n+\tassert(bs->ops == NULL);\n+\tbs->ops = &strbuf_vtable;\n+\tbs->arg = buf;\n+}\n+\n+static void malloc_return_block(void *b, struct reftable_block *dest)\n+{\n+\tmemset(dest->data, 0xff, dest->len);\n+\treftable_free(dest->data);\n+}\n+\n+static struct reftable_block_source_vtable malloc_vtable = {\n+\t.return_block = &malloc_return_block,\n+};\n+\n+static struct reftable_block_source malloc_block_source_instance = {\n+\t.ops = &malloc_vtable,\n+};\n+\n+struct reftable_block_source malloc_block_source(void)\n+{\n+\treturn malloc_block_source_instance;\n+}\n+\n+struct file_block_source {\n+\tint fd;\n+\tuint64_t size;\n+};\n+\n+static uint64_t file_size(void *b)\n+{\n+\treturn ((struct file_block_source *)b)->size;\n+}\n+\n+static void file_return_block(void *b, struct reftable_block *dest)\n+{\n+\tmemset(dest->data, 0xff, dest->len);\n+\treftable_free(dest->data);\n+}\n+\n+static void file_close(void *b)\n+{\n+\tint fd = ((struct file_block_source *)b)->fd;\n+\tif (fd > 0) {\n+\t\tclose(fd);\n+\t\t((struct file_block_source *)b)->fd = 0;\n+\t}\n+\n+\treftable_free(b);\n+}\n+\n+static int file_read_block(void *v, struct reftable_block *dest, uint64_t off,\n+\t\t\t uint32_t size)\n+{\n+\tstruct file_block_source *b = (struct file_block_source *)v;\n+\tassert(off + size <= b->size);\n+\tdest->data = reftable_malloc(size);\n+\tif (pread(b->fd, dest->data, size, off) != size)\n+\t\treturn -1;\n+\tdest->len = size;\n+\treturn size;\n+}\n+\n+static struct reftable_block_source_vtable file_vtable = {\n+\t.size = &file_size,\n+\t.return_block = &file_return_block,\n+\t.close = &file_close,\n+};\n+\n+int reftable_block_source_from_file(struct reftable_block_source *bs,\n+\t\t\t\t const char *name)\n+{\n+\tstruct stat st = { 0 };\n+\tint err = 0;\n+\tint fd = open(name, O_RDONLY);\n+\tstruct file_block_source *p = NULL;\n+\tif (fd < 0) {\n+\t\tif (errno == ENOENT) {\n+\t\t\treturn REFTABLE_NOT_EXIST_ERROR;\n+\t\t}\n+\t\treturn -1;\n+\t}\n+\n+\terr = fstat(fd, &st);\n+\tif (err < 0)\n+\t\treturn -1;\n+\n+\tp = reftable_calloc(sizeof(struct file_block_source));\n+\tp->size = st.st_size;\n+\tp->fd = fd;\n+\n+\tassert(bs->ops == NULL);\n+\tbs->ops = &file_vtable;\n+\tbs->arg = p;\n+\treturn 0;\n+}\ndiff --git a/reftable/blocksource.h b/reftable/blocksource.h\nnew file mode 100644\nindex 0000000000..3faf83fa9d\n--- /dev/null\n+++ b/reftable/blocksource.h\n@@ -0,0 +1,22 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#ifndef BLOCKSOURCE_H\n+#define BLOCKSOURCE_H\n+\n+#include \"strbuf.h\"\n+\n+struct reftable_block_source;\n+\n+/* Create an in-memory block source for reading reftables */\n+void block_source_from_strbuf(struct reftable_block_source *bs,\n+\t\t\t struct strbuf *buf);\n+\n+struct reftable_block_source malloc_block_source(void);\n+\n+#endif\ndiff --git a/reftable/compat.c b/reftable/compat.c\nnew file mode 100644\nindex 0000000000..a48c5aa5e3\n--- /dev/null\n+++ b/reftable/compat.c\n@@ -0,0 +1,110 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+\n+*/\n+\n+/* compat.c - compatibility functions for standalone compilation */\n+\n+#include \"system.h\"\n+#include \"basics.h\"\n+\n+#ifdef REFTABLE_STANDALONE\n+\n+#include <dirent.h>\n+\n+void put_be32(void *p, uint32_t i)\n+{\n+\tuint8_t *out = (uint8_t *)p;\n+\n+\tout = (uint8_t)((i >> 24) & 0xff);\n+\tout = (uint8_t)((i >> 16) & 0xff);\n+\tout = (uint8_t)((i >> 8) & 0xff);\n+\tout = (uint8_t)((i)&0xff);\n+}\n+\n+uint32_t get_be32(uint8_t *in)\n+{\n+\treturn (uint32_t)(in) << 24 | (uint32_t)(in) << 16 |\n+\t (uint32_t)(in) << 8 | (uint32_t)(in);\n+}\n+\n+void put_be64(void *p, uint64_t v)\n+{\n+\tuint8_t *out = (uint8_t *)p;\n+\tint i = sizeof(uint64_t);\n+\twhile (i--) {\n+\t\tout[i] = (uint8_t)(v & 0xff);\n+\t\tv >>= 8;\n+\t}\n+}\n+\n+uint64_t get_be64(void *out)\n+{\n+\tuint8_t *bytes = (uint8_t *)out;\n+\tuint64_t v = 0;\n+\tint i = 0;\n+\tfor (i = 0; i < sizeof(uint64_t); i++) {\n+\t\tv = (v << 8) | (uint8_t)(bytes[i] & 0xff);\n+\t}\n+\treturn v;\n+}\n+\n+uint16_t get_be16(uint8_t *in)\n+{\n+\treturn (uint32_t)(in) << 8 | (uint32_t)(in);\n+}\n+\n+char *xstrdup(const char *s)\n+{\n+\tint l = strlen(s);\n+\tchar *dest = (char *)reftable_malloc(l + 1);\n+\tstrncpy(dest, s, l + 1);\n+\treturn dest;\n+}\n+\n+void sleep_millisec(int millisecs)\n+{\n+\tusleep(millisecs * 1000);\n+}\n+\n+void reftable_clear_dir(const char *dirname)\n+{\n+\tDIR *dir = opendir(dirname);\n+\tstruct dirent *ent = NULL;\n+\tassert(dir);\n+\twhile ((ent = readdir(dir)) != NULL) {\n+\t}\n+\tclosedir(dir);\n+\trmdir(dirname);\n+}\n+\n+#else\n+\n+#include \"../dir.h\"\n+\n+void reftable_clear_dir(const char *dirname)\n+{\n+\tstruct strbuf path = STRBUF_INIT;\n+\tremove_dir_recursively(&path, 0);\n+\tstrbuf_release(&path);\n+}\n+\n+#endif\n+\n+int hash_size(uint32_t id)\n+{\n+\tswitch (id) {\n+\tcase 0:\n+\tcase SHA1_ID:\n+\t\treturn SHA1_SIZE;\n+\tcase SHA256_ID:\n+\t\treturn SHA256_SIZE;\n+\t}\n+\tabort();\n+}\ndiff --git a/reftable/compat.h b/reftable/compat.h\nnew file mode 100644\nindex 0000000000..a765c57e96\n--- /dev/null\n+++ b/reftable/compat.h\n@@ -0,0 +1,48 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#ifndef COMPAT_H\n+#define COMPAT_H\n+\n+#include \"system.h\"\n+\n+#ifdef REFTABLE_STANDALONE\n+\n+/* functions that git-core provides, for standalone compilation */\n+#include <stdint.h>\n+\n+uint64_t get_be64(void *in);\n+void put_be64(void *out, uint64_t i);\n+\n+void put_be32(void *out, uint32_t i);\n+uint32_t get_be32(uint8_t *in);\n+\n+uint16_t get_be16(uint8_t *in);\n+\n+#define ARRAY_SIZE(a) sizeof((a)) / sizeof((a))\n+#define FREE_AND_NULL(x) \\\n+\tdo { \\\n+\t\treftable_free(x); \\\n+\t\t(x) = NULL; \\\n+\t} while (0)\n+#define QSORT(arr, n, cmp) qsort(arr, n, sizeof(arr), cmp)\n+#define SWAP(a, b) \\\n+\t{ \\\n+\t\tchar tmp[sizeof(a)]; \\\n+\t\tassert(sizeof(a) == sizeof(b)); \\\n+\t\tmemcpy(&tmp, &a, sizeof(a)); \\\n+\t\tmemcpy(&a, &b, sizeof(a)); \\\n+\t\tmemcpy(&b, &tmp, sizeof(a)); \\\n+\t}\n+\n+char *xstrdup(const char *s);\n+\n+void sleep_millisec(int millisecs);\n+\n+#endif\n+#endif\ndiff --git a/reftable/publicbasics.c b/reftable/publicbasics.c\nnew file mode 100644\nindex 0000000000..12d547d70d\n--- /dev/null\n+++ b/reftable/publicbasics.c\n@@ -0,0 +1,100 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"reftable.h\"\n+\n+#include \"basics.h\"\n+#include \"system.h\"\n+\n+const char *reftable_error_str(int err)\n+{\n+\tstatic char buf;\n+\tswitch (err) {\n+\tcase REFTABLE_IO_ERROR:\n+\t\treturn \"I/O error\";\n+\tcase REFTABLE_FORMAT_ERROR:\n+\t\treturn \"corrupt reftable file\";\n+\tcase REFTABLE_NOT_EXIST_ERROR:\n+\t\treturn \"file does not exist\";\n+\tcase REFTABLE_LOCK_ERROR:\n+\t\treturn \"data is outdated\";\n+\tcase REFTABLE_API_ERROR:\n+\t\treturn \"misuse of the reftable API\";\n+\tcase REFTABLE_ZLIB_ERROR:\n+\t\treturn \"zlib failure\";\n+\tcase REFTABLE_NAME_CONFLICT:\n+\t\treturn \"file/directory conflict\";\n+\tcase REFTABLE_REFNAME_ERROR:\n+\t\treturn \"invalid refname\";\n+\tcase -1:\n+\t\treturn \"general error\";\n+\tdefault:\n+\t\tsnprintf(buf, sizeof(buf), \"unknown error code %d\", err);\n+\t\treturn buf;\n+\t}\n+}\n+\n+int reftable_error_to_errno(int err)\n+{\n+\tswitch (err) {\n+\tcase REFTABLE_IO_ERROR:\n+\t\treturn EIO;\n+\tcase REFTABLE_FORMAT_ERROR:\n+\t\treturn EFAULT;\n+\tcase REFTABLE_NOT_EXIST_ERROR:\n+\t\treturn ENOENT;\n+\tcase REFTABLE_LOCK_ERROR:\n+\t\treturn EBUSY;\n+\tcase REFTABLE_API_ERROR:\n+\t\treturn EINVAL;\n+\tcase REFTABLE_ZLIB_ERROR:\n+\t\treturn EDOM;\n+\tdefault:\n+\t\treturn ERANGE;\n+\t}\n+}\n+\n+static void *(*reftable_malloc_ptr)(size_t sz) = &malloc;\n+static void *(*reftable_realloc_ptr)(void *, size_t) = &realloc;\n+static void (*reftable_free_ptr)(void *) = &free;\n+\n+void *reftable_malloc(size_t sz)\n+{\n+\treturn (*reftable_malloc_ptr)(sz);\n+}\n+\n+void *reftable_realloc(void *p, size_t sz)\n+{\n+\treturn (*reftable_realloc_ptr)(p, sz);\n+}\n+\n+void reftable_free(void *p)\n+{\n+\treftable_free_ptr(p);\n+}\n+\n+void *reftable_calloc(size_t sz)\n+{\n+\tvoid *p = reftable_malloc(sz);\n+\tmemset(p, 0, sz);\n+\treturn p;\n+}\n+\n+void reftable_set_alloc(void *(*malloc)(size_t),\n+\t\t\tvoid *(*realloc)(void *, size_t), void (*free)(void *))\n+{\n+\treftable_malloc_ptr = malloc;\n+\treftable_realloc_ptr = realloc;\n+\treftable_free_ptr = free;\n+}\n+\n+int reftable_fd_write(void *arg, const void *data, size_t sz)\n+{\n+\tint *fdp = (int *)arg;\n+\treturn write(*fdp, data, sz);\n+}\ndiff --git a/reftable/reftable-tests.h b/reftable/reftable-tests.h\nnew file mode 100644\nindex 0000000000..e38471888f\n--- /dev/null\n+++ b/reftable/reftable-tests.h\n@@ -0,0 +1,22 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#ifndef REFTABLE_TESTS_H\n+#define REFTABLE_TESTS_H\n+\n+int block_test_main(int argc, const char **argv);\n+int merged_test_main(int argc, const char **argv);\n+int record_test_main(int argc, const char **argv);\n+int refname_test_main(int argc, const char **argv);\n+int reftable_test_main(int argc, const char **argv);\n+int strbuf_test_main(int argc, const char **argv);\n+int stack_test_main(int argc, const char **argv);\n+int tree_test_main(int argc, const char **argv);\n+int reftable_dump_main(int argc, char *const *argv);\n+\n+#endif\ndiff --git a/reftable/strbuf.c b/reftable/strbuf.c\nnew file mode 100644\nindex 0000000000..136bf65591\n--- /dev/null\n+++ b/reftable/strbuf.c\n@@ -0,0 +1,142 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"strbuf.h\"\n+\n+#ifdef REFTABLE_STANDALONE\n+\n+void strbuf_init(struct strbuf *s, size_t alloc)\n+{\n+\tstruct strbuf empty = STRBUF_INIT;\n+\t*s = empty;\n+}\n+\n+void strbuf_grow(struct strbuf *s, size_t extra)\n+{\n+\tsize_t newcap = s->len + extra + 1;\n+\tif (newcap > s->cap) {\n+\t\ts->buf = reftable_realloc(s->buf, newcap);\n+\t\ts->cap = newcap;\n+\t}\n+}\n+\n+static void strbuf_resize(struct strbuf *s, int l)\n+{\n+\tint zl = l + 1; /* one uint8_t for 0 termination. */\n+\tassert(s->canary == STRBUF_CANARY);\n+\tif (s->cap < zl) {\n+\t\tint c = s->cap * 2;\n+\t\tif (c < zl) {\n+\t\t\tc = zl;\n+\t\t}\n+\t\ts->cap = c;\n+\t\ts->buf = reftable_realloc(s->buf, s->cap);\n+\t}\n+\ts->len = l;\n+\ts->buf[l] = 0;\n+}\n+\n+void strbuf_setlen(struct strbuf *s, size_t l)\n+{\n+\tassert(s->cap >= l + 1);\n+\ts->len = l;\n+\ts->buf[l] = 0;\n+}\n+\n+void strbuf_reset(struct strbuf *s)\n+{\n+\tstrbuf_resize(s, 0);\n+}\n+\n+void strbuf_addstr(struct strbuf *d, const char *s)\n+{\n+\tint l1 = d->len;\n+\tint l2 = strlen(s);\n+\tassert(d->canary == STRBUF_CANARY);\n+\n+\tstrbuf_resize(d, l2 + l1);\n+\tmemcpy(d->buf + l1, s, l2);\n+}\n+\n+void strbuf_addbuf(struct strbuf *s, struct strbuf *a)\n+{\n+\tint end = s->len;\n+\tassert(s->canary == STRBUF_CANARY);\n+\tstrbuf_resize(s, s->len + a->len);\n+\tmemcpy(s->buf + end, a->buf, a->len);\n+}\n+\n+char *strbuf_detach(struct strbuf *s, size_t *sz)\n+{\n+\tchar *p = NULL;\n+\tp = (char *)s->buf;\n+\tif (sz)\n+\t\t*sz = s->len;\n+\ts->buf = NULL;\n+\ts->cap = 0;\n+\ts->len = 0;\n+\treturn p;\n+}\n+\n+void strbuf_release(struct strbuf *s)\n+{\n+\tassert(s->canary == STRBUF_CANARY);\n+\ts->cap = 0;\n+\ts->len = 0;\n+\treftable_free(s->buf);\n+\ts->buf = NULL;\n+}\n+\n+int strbuf_cmp(const struct strbuf *a, const struct strbuf *b)\n+{\n+\tint min = a->len < b->len ? a->len : b->len;\n+\tint res = memcmp(a->buf, b->buf, min);\n+\tassert(a->canary == STRBUF_CANARY);\n+\tassert(b->canary == STRBUF_CANARY);\n+\tif (res != 0)\n+\t\treturn res;\n+\tif (a->len < b->len)\n+\t\treturn -1;\n+\telse if (a->len > b->len)\n+\t\treturn 1;\n+\telse\n+\t\treturn 0;\n+}\n+\n+int strbuf_add(struct strbuf *b, const void *data, size_t sz)\n+{\n+\tassert(b->canary == STRBUF_CANARY);\n+\tstrbuf_grow(b, sz);\n+\tmemcpy(b->buf + b->len, data, sz);\n+\tb->len += sz;\n+\tb->buf[b->len] = 0;\n+\treturn sz;\n+}\n+\n+#endif\n+\n+int strbuf_add_void(void *b, const void *data, size_t sz)\n+{\n+\tstrbuf_add((struct strbuf *)b, data, sz);\n+\treturn sz;\n+}\n+\n+int common_prefix_size(struct strbuf *a, struct strbuf *b)\n+{\n+\tint p = 0;\n+\twhile (p < a->len && p < b->len) {\n+\t\tif (a->buf[p] != b->buf[p]) {\n+\t\t\tbreak;\n+\t\t}\n+\t\tp++;\n+\t}\n+\n+\treturn p;\n+}\n+\n+struct strbuf reftable_empty_strbuf = STRBUF_INIT;\ndiff --git a/reftable/strbuf.h b/reftable/strbuf.h\nnew file mode 100644\nindex 0000000000..c2d7aca8dd\n--- /dev/null\n+++ b/reftable/strbuf.h\n@@ -0,0 +1,80 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#ifndef SLICE_H\n+#define SLICE_H\n+\n+#ifdef REFTABLE_STANDALONE\n+\n+#include \"basics.h\"\n+\n+/*\n+ Provides a bounds-checked, growable byte ranges. To use, initialize as \"strbuf\n+ x = STRBUF_INIT;\"\n+ */\n+struct strbuf {\n+\tsize_t len;\n+\tsize_t cap;\n+\tchar *buf;\n+\n+\t/* Used to enforce initialization with STRBUF_INIT */\n+\tuint8_t canary;\n+};\n+\n+#define STRBUF_CANARY 0x42\n+#define STRBUF_INIT \\\n+\t{ \\\n+\t\t0, 0, NULL, STRBUF_CANARY \\\n+\t}\n+\n+void strbuf_addstr(struct strbuf *dest, const char *src);\n+\n+/* Deallocate and clear strbuf */\n+void strbuf_release(struct strbuf *strbuf);\n+\n+/* Set strbuf to 0 length, but retain buffer. */\n+void strbuf_reset(struct strbuf *strbuf);\n+\n+/* Initializes a strbuf. Accepts a strbuf with random garbage. */\n+void strbuf_init(struct strbuf *strbuf, size_t alloc);\n+\n+/* Return `buf`, clearing out `s`. Optionally return len (not cap) in `sz`. */\n+char *strbuf_detach(struct strbuf *s, size_t *sz);\n+\n+/* Set length of the slace to `l`, but don't reallocated. */\n+void strbuf_setlen(struct strbuf *s, size_t l);\n+\n+/* Ensure `l` bytes beyond current length are available */\n+void strbuf_grow(struct strbuf *s, size_t l);\n+\n+/* Signed comparison */\n+int strbuf_cmp(const struct strbuf *a, const struct strbuf *b);\n+\n+/* Append `data` to the `dest` strbuf. */\n+int strbuf_add(struct strbuf *dest, const void *data, size_t sz);\n+\n+/* Append `add` to `dest. */\n+\n+#else\n+\n+#include \"../git-compat-util.h\"\n+#include \"../strbuf.h\"\n+\n+#endif\n+\n+extern struct strbuf reftable_empty_strbuf;\n+\n+/* Like strbuf_add, but suitable for passing to reftable_new_writer\n+ */\n+int strbuf_add_void(void *b, const void *data, size_t sz);\n+\n+/* Find the longest shared prefix size of `a` and `b` */\n+int common_prefix_size(struct strbuf *a, struct strbuf *b);\n+\n+#endif\ndiff --git a/reftable/strbuf_test.c b/reftable/strbuf_test.c\nnew file mode 100644\nindex 0000000000..39f561c81a\n--- /dev/null\n+++ b/reftable/strbuf_test.c\n@@ -0,0 +1,37 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"strbuf.h\"\n+\n+#include \"system.h\"\n+\n+#include \"basics.h\"\n+#include \"test_framework.h\"\n+#include \"reftable-tests.h\"\n+\n+static void test_strbuf(void)\n+{\n+\tstruct strbuf s = STRBUF_INIT;\n+\tstruct strbuf t = STRBUF_INIT;\n+\n+\tassert(0 == strcmp(\"abc\", s.buf));\n+\n+\tassert(0 == strcmp(\"abcpqr\", s.buf));\n+\n+\tstrbuf_release(&s);\n+\tstrbuf_release(&t);\n+}\n+\n+int strbuf_test_main(int argc, const char *argv[])\n+{\n+\treturn test_main(argc, argv);\n+}\ndiff --git a/reftable/system.h b/reftable/system.h\nnew file mode 100644\nindex 0000000000..567eb8a87d\n--- /dev/null\n+++ b/reftable/system.h\n@@ -0,0 +1,51 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#ifndef SYSTEM_H\n+#define SYSTEM_H\n+\n+#ifndef REFTABLE_STANDALONE\n+\n+#include \"git-compat-util.h\"\n+#include \"cache.h\"\n+#include <zlib.h>\n+\n+#else\n+\n+#include <assert.h>\n+#include <errno.h>\n+#include <fcntl.h>\n+#include <inttypes.h>\n+#include <stdint.h>\n+#include <stdio.h>\n+#include <stdlib.h>\n+#include <string.h>\n+#include <sys/stat.h>\n+#include <sys/time.h>\n+#include <sys/types.h>\n+#include <unistd.h>\n+#include <zlib.h>\n+\n+#include \"compat.h\"\n+\n+#endif /* REFTABLE_STANDALONE */\n+\n+void reftable_clear_dir(const char *dirname);\n+\n+#define SHA1_ID 0x73686131\n+#define SHA256_ID 0x73323536\n+#define SHA1_SIZE 20\n+#define SHA256_SIZE 32\n+\n+/* This is uncompress2, which is only available in zlib as of 2017.\n+ */\n+int uncompress_return_consumed(Bytef *dest, uLongf *destLen,\n+\t\t\t const Bytef *source, uLong *sourceLen);\n+int hash_size(uint32_t id);\n+\n+#endif\ndiff --git a/t/helper/test-reftable.c b/t/helper/test-reftable.c\nnew file mode 100644\nindex 0000000000..7d50aa6bcc\n--- /dev/null\n+++ b/t/helper/test-reftable.c\n@@ -0,0 +1,8 @@\n+#include \"reftable/reftable-tests.h\"\n+#include \"test-tool.h\"\n+\n+int cmd__reftable(int argc, const char **argv)\n+{\n+\tstrbuf_test_main(argc, argv);\n+\treturn 0;\n+}\ndiff --git a/t/helper/test-tool.c b/t/helper/test-tool.c\nindex a0d3966b29..c7ab5bc4a6 100644\n--- a/t/helper/test-tool.c\n+++ b/t/helper/test-tool.c\n@@ -53,6 +53,7 @@ static struct test_cmd cmds[] = {\n{ \"ref-store\", cmd__ref_store },\n+\t{ \"reftable\", cmd__reftable },\n{ \"regex\", cmd__regex },\n{ \"repository\", cmd__repository },\n{ \"revision-walking\", cmd__revision_walking },\ndiff --git a/t/helper/test-tool.h b/t/helper/test-tool.h\nindex 07034d3f38..fa2b11ace6 100644\n--- a/t/helper/test-tool.h\n+++ b/t/helper/test-tool.h\n@@ -42,6 +42,7 @@ int cmd__read_cache(int argc, const char **argv);\nint cmd__read_graph(int argc, const char **argv);\nint cmd__read_midx(int argc, const char **argv);\nint cmd__ref_store(int argc, const char **argv);\n+int cmd__reftable(int argc, const char **argv);\nint cmd__regex(int argc, const char **argv);\nint cmd__repository(int argc, const char **argv);\nint cmd__revision_walking(int argc, const char **argv);\n--\n\n• ```* Re: [PATCH v2 05/13] reftable: utility functions\n2020-10-01 16:10 ` [PATCH v2 05/13] reftable: utility functions Han-Wen Nienhuys via GitGitGadget\n@ 2020-10-02 4:12 ` Jonathan Nieder\n2020-10-10 17:32 ` Han-Wen Nienhuys\n2020-10-02 14:01 ` Johannes Schindelin\n2020-10-08 1:48 ` Jonathan Tan\nFrom: Jonathan Nieder @ 2020-10-02 4:12 UTC (permalink / raw)\nCc: git, Han-Wen Nienhuys, Jeff King, Han-Wen Nienhuys\n\nHan-Wen Nienhuys wrote:\n\n> --- /dev/null\n> +++ b/reftable/basics.c\n> @@ -0,0 +1,131 @@\n> +/*\n> +\n> +Use of this source code is governed by a BSD-style\n> +license that can be found in the LICENSE file or at\n> +*/\n> +\n> +#include \"basics.h\"\n\nwe approach that here?\n\nE.g. would we pass -include on the command line, or could we #include\nsome kind of compat-util.h that #include-s \"git-compat-util.h\" in Git\nand does the appropriate steps for enabling feature test macros and\nincluding system headers when used outside?\n\n[...]\n> +int binsearch(size_t sz, int (*f)(size_t k, void *args), void *args)\n\nHow does this compare to stdlib's bsearch?\n\n[...]\n> +void free_names(char **a)\n> +{\n> +\tchar **p = a;\n> +\tif (p == NULL) {\n> +\t\treturn;\n> +\t}\n> +\twhile (*p) {\n> +\t\treftable_free(*p);\n> +\t\tp++;\n> +\t}\n> +\treftable_free(a);\n> +}\n\nAre there other callers that need custom free?\n\n[...]\n> +int names_length(char **names)\n> +{\n> +\tint len = 0;\n> +\tchar **p = names;\n> +\twhile (*p) {\n> +\t\tp++;\n> +\t\tlen++;\n> +\t}\n> +\treturn len;\n> +}\n\nThe rest are probably easier to evaluate when I look at the callers, and\nit's time for me to go to sleep now. I'll try to find some time soon to\npick the review back up.\n\nThanks for a thoughtfully put together library so far.\n\nJonathan\n\n• ```* Re: [PATCH v2 05/13] reftable: utility functions\n2020-10-02 4:12 ` Jonathan Nieder\n@ 2020-10-10 17:32 ` Han-Wen Nienhuys\n2020-10-12 15:25 ` Jonathan Nieder\nFrom: Han-Wen Nienhuys @ 2020-10-10 17:32 UTC (permalink / raw)\nTo: Jonathan Nieder\nCc: Han-Wen Nienhuys via GitGitGadget, git, Jeff King, Han-Wen Nienhuys\n\nOn Fri, Oct 2, 2020 at 6:12 AM Jonathan Nieder <[email protected]> wrote:\n> [...]\n> > +int binsearch(size_t sz, int (*f)(size_t k, void *args), void *args)\n>\n> How does this compare to stdlib's bsearch?\n\nbsearch gives you back NULL if it doesn't find an exact match.\n\n> > + reftable_free(a);\n> > +}\n>\n> Are there other callers that need custom free?\n\nThe libgit2 folks requested the ability to set memory allocation\nroutines, hence reftable_free().\n\n--\nI work 80%. Don't expect answers from me on Fridays.\n--\n\nGoogle Germany GmbH, Erika-Mann-Strasse 33, 80636 Munich\n\nRegistergericht und -nummer: Hamburg, HRB 86891\n\nSitz der Gesellschaft: Hamburg\n\nGeschäftsführer: Paul Manicle, Halimah DeLaine Prado\n\n• ```* Re: [PATCH v2 05/13] reftable: utility functions\n2020-10-10 17:32 ` Han-Wen Nienhuys\n@ 2020-10-12 15:25 ` Jonathan Nieder\n2020-10-12 17:05 ` Patrick Steinhardt\nFrom: Jonathan Nieder @ 2020-10-12 15:25 UTC (permalink / raw)\nTo: Han-Wen Nienhuys\nCc: Han-Wen Nienhuys via GitGitGadget, git, Jeff King,\nHan-Wen Nienhuys, Patrick Steinhardt\n\n(+cc: Patrick Steinhardt from libgit2)\nHi,\n\nHan-Wen Nienhuys wrote:\n> On Fri, Oct 2, 2020 at 6:12 AM Jonathan Nieder <[email protected]> wrote:\n>> Han-Wen Nienhuys wrote:\n\n>>> + reftable_free(a);\n>>> +}\n>>\n>> Are there other callers that need custom free?\n>\n> The libgit2 folks requested the ability to set memory allocation\n> routines, hence reftable_free().\n\ncase? That would help with making sure we are making an API that\nmeets its needs.\n\nFor example, is a custom allocator something that would be set\nglobally or something attached to a handle? If the former, would code\nthat uses xmalloc and free and gets #define-d away when used in\nlibgit2 work? If the latter, what does the handle look like?\n\nThanks,\nJonathan\n\n• ```* Re: [PATCH v2 05/13] reftable: utility functions\n2020-10-12 15:25 ` Jonathan Nieder\n@ 2020-10-12 17:05 ` Patrick Steinhardt\n2020-10-12 17:45 ` Jonathan Nieder\n2020-10-13 12:12 ` Johannes Schindelin\n0 siblings, 2 replies; 251+ messages in thread\nFrom: Patrick Steinhardt @ 2020-10-12 17:05 UTC (permalink / raw)\nTo: Jonathan Nieder\nCc: Han-Wen Nienhuys, Han-Wen Nienhuys via GitGitGadget, git,\nJeff King, Han-Wen Nienhuys\n\n[-- Attachment #1: Type: text/plain, Size: 2266 bytes --]\n\nOn Mon, Oct 12, 2020 at 08:25:05AM -0700, Jonathan Nieder wrote:\n> (+cc: Patrick Steinhardt from libgit2)\n> Hi,\n>\n> Han-Wen Nienhuys wrote:\n> > On Fri, Oct 2, 2020 at 6:12 AM Jonathan Nieder <[email protected]> wrote:\n> >> Han-Wen Nienhuys wrote:\n>\n> >>> + reftable_free(a);\n> >>> +}\n> >>\n> >> Are there other callers that need custom free?\n> >\n> > The libgit2 folks requested the ability to set memory allocation\n> > routines, hence reftable_free().\n>\n> case? That would help with making sure we are making an API that\n> meets its needs.\n>\n> For example, is a custom allocator something that would be set\n> globally or something attached to a handle? If the former, would code\n> that uses xmalloc and free and gets #define-d away when used in\n> libgit2 work? If the latter, what does the handle look like?\n\nWe have global pluggable allocators in libgit2 which can be set up\nbefore calling `git_libgit2_init()`. The user of libgit2 can fill a\n`git_allocator` structure with a set of funtcion pointers, most\nimportantly with implementations of `free` and `malloc`. Those then get\nused across all of libgit2 for all subsequent allocations.\n\nIn order to be as thorough as possible, we thus also need to replace\nthese function pointers for libgit2's dependencies. As registration of\nthe allocator happens at runtime, we need to also be able to replace\nfunction pointers of dependencies at runtime. E.g. for OpenSSL, it\nprovides an API `CRYPTO_set_mem_functions(malloc, realloc, free)` which\nwe call on global initialization of the libgit2 library.\n\n- The allocator is global and cannot be changed after initialization\nof libgit2.\n\n- It is pluggable, users can set up their own allocators by filling\na structure with function pointers for `free`, `malloc`, `realloc`\netc.\n\n- Due to the pluggable nature, we need to be able to set up those\npointers at runtime. We can provide a set of static wrappers\nthough which then call into the pluggable functions, so defines\nwould probably work for us, too.\n\nPatrick\n\n[-- Attachment #2: signature.asc --]\n[-- Type: application/pgp-signature, Size: 833 bytes --]\n\n• ```* Re: [PATCH v2 05/13] reftable: utility functions\n2020-10-12 17:05 ` Patrick Steinhardt\n@ 2020-10-12 17:45 ` Jonathan Nieder\n2020-10-13 12:12 ` Johannes Schindelin\n1 sibling, 0 replies; 251+ messages in thread\nFrom: Jonathan Nieder @ 2020-10-12 17:45 UTC (permalink / raw)\nTo: Patrick Steinhardt\nCc: Han-Wen Nienhuys, Han-Wen Nienhuys via GitGitGadget, git,\nJeff King, Han-Wen Nienhuys\n\nPatrick Steinhardt wrote:\n\n> In order to be as thorough as possible, we thus also need to replace\n> these function pointers for libgit2's dependencies. As registration of\n> the allocator happens at runtime, we need to also be able to replace\n> function pointers of dependencies at runtime. E.g. for OpenSSL, it\n> provides an API `CRYPTO_set_mem_functions(malloc, realloc, free)` which\n> we call on global initialization of the libgit2 library.\n>\n>\n> - The allocator is global and cannot be changed after initialization\n> of libgit2.\n>\n> - It is pluggable, users can set up their own allocators by filling\n> a structure with function pointers for `free`, `malloc`, `realloc`\n> etc.\n>\n> - Due to the pluggable nature, we need to be able to set up those\n> pointers at runtime. We can provide a set of static wrappers\n> though which then call into the pluggable functions, so defines\n> would probably work for us, too.\n>\n\nJonathan\n\n• ```* Re: [PATCH v2 05/13] reftable: utility functions\n2020-10-12 17:05 ` Patrick Steinhardt\n2020-10-12 17:45 ` Jonathan Nieder\n@ 2020-10-13 12:12 ` Johannes Schindelin\n2020-10-13 15:47 ` Junio C Hamano\nFrom: Johannes Schindelin @ 2020-10-13 12:12 UTC (permalink / raw)\nTo: Patrick Steinhardt\nCc: Jonathan Nieder, Han-Wen Nienhuys,\nHan-Wen Nienhuys via GitGitGadget, git, Jeff King,\nHan-Wen Nienhuys\n\nHi Patrick,\n\nOn Mon, 12 Oct 2020, Patrick Steinhardt wrote:\n\n> On Mon, Oct 12, 2020 at 08:25:05AM -0700, Jonathan Nieder wrote:\n> > (+cc: Patrick Steinhardt from libgit2)\n> > Hi,\n> >\n> > Han-Wen Nienhuys wrote:\n> > > On Fri, Oct 2, 2020 at 6:12 AM Jonathan Nieder <[email protected]> wrote:\n> > >> Han-Wen Nienhuys wrote:\n> >\n> > >>> + reftable_free(a);\n> > >>> +}\n> > >>\n> > >> Are there other callers that need custom free?\n> > >\n> > > The libgit2 folks requested the ability to set memory allocation\n> > > routines, hence reftable_free().\n> >\n> > case? That would help with making sure we are making an API that\n> > meets its needs.\n> >\n> > For example, is a custom allocator something that would be set\n> > globally or something attached to a handle? If the former, would code\n> > that uses xmalloc and free and gets #define-d away when used in\n> > libgit2 work? If the latter, what does the handle look like?\n>\n> We have global pluggable allocators in libgit2 which can be set up\n> before calling `git_libgit2_init()`. The user of libgit2 can fill a\n> `git_allocator` structure with a set of funtcion pointers, most\n> importantly with implementations of `free` and `malloc`. Those then get\n> used across all of libgit2 for all subsequent allocations.\n\nI did not find out how those are used in the `deps/` part of libgit2's\nsource code. For example, I see a couple of instances where `malloc()` is\nused in `ntlmclient` and in `pcre`.\n\nThe thing I was looking for would have been something like\n\n#define malloc(size) git__malloc(size)\n...\n\nThis would also have been what I imagined to be the best strategy to\nintegrate the reftable code once it is properly embedded in libgit.a (and\nof course using libgit.a's API as much as it can).\n\nSomewhat related: I was wondering whether it would make sense for git.git\nto rename `strbuf` to `git_buf`? Would that make it easier to exchange\ncode between the two projects? Or would it just be unnecessary churn?\n\nCiao,\nDscho\n\n• ```* Re: [PATCH v2 05/13] reftable: utility functions\n2020-10-13 12:12 ` Johannes Schindelin\n@ 2020-10-13 15:47 ` Junio C Hamano\n2020-10-15 11:46 ` Johannes Schindelin\nFrom: Junio C Hamano @ 2020-10-13 15:47 UTC (permalink / raw)\nTo: Johannes Schindelin\nCc: Patrick Steinhardt, Jonathan Nieder, Han-Wen Nienhuys,\nHan-Wen Nienhuys via GitGitGadget, git, Jeff King,\nHan-Wen Nienhuys\n\nJohannes Schindelin <[email protected]> writes:\n\n> Somewhat related: I was wondering whether it would make sense for git.git\n> to rename `strbuf` to `git_buf`? Would that make it easier to exchange\n> code between the two projects? Or would it just be unnecessary churn?\n\nTo us, \"git_buf\" is just as descriptive as \"buf\" and does not say\nanything about the nature of 'buf' (other than apparently it was\ninvented and widely used here). \"git_strbuf\" I can understand, but\nwhy should we?\n\n• ```* Re: [PATCH v2 05/13] reftable: utility functions\n2020-10-13 15:47 ` Junio C Hamano\n@ 2020-10-15 11:46 ` Johannes Schindelin\n2020-10-15 16:23 ` Junio C Hamano\nFrom: Johannes Schindelin @ 2020-10-15 11:46 UTC (permalink / raw)\nTo: Junio C Hamano\nCc: Patrick Steinhardt, Jonathan Nieder, Han-Wen Nienhuys,\nHan-Wen Nienhuys via GitGitGadget, git, Jeff King,\nHan-Wen Nienhuys\n\nHi Junio,\n\nOn Tue, 13 Oct 2020, Junio C Hamano wrote:\n\n> Johannes Schindelin <[email protected]> writes:\n>\n> > Somewhat related: I was wondering whether it would make sense for git.git\n> > to rename `strbuf` to `git_buf`? Would that make it easier to exchange\n> > code between the two projects? Or would it just be unnecessary churn?\n>\n> To us, \"git_buf\" is just as descriptive as \"buf\" and does not say\n> anything about the nature of 'buf' (other than apparently it was\n> invented and widely used here). \"git_strbuf\" I can understand, but\n> why should we?\n\nIf it makes code sharing between git.git and libgit2 easier, why shouldn't\nwe ;-)\n\nObviously, if it doesn't make life easier, we shouldn't bother.\n\nCiao,\nDscho\n\n• ```* Re: [PATCH v2 05/13] reftable: utility functions\n2020-10-15 11:46 ` Johannes Schindelin\n@ 2020-10-15 16:23 ` Junio C Hamano\n2020-10-15 19:39 ` Johannes Schindelin\n2020-10-16 9:15 ` Patrick Steinhardt\n0 siblings, 2 replies; 251+ messages in thread\nFrom: Junio C Hamano @ 2020-10-15 16:23 UTC (permalink / raw)\nTo: Johannes Schindelin\nCc: Patrick Steinhardt, Jonathan Nieder, Han-Wen Nienhuys,\nHan-Wen Nienhuys via GitGitGadget, git, Jeff King,\nHan-Wen Nienhuys\n\nJohannes Schindelin <[email protected]> writes:\n\n> Hi Junio,\n>\n> On Tue, 13 Oct 2020, Junio C Hamano wrote:\n>\n>> Johannes Schindelin <[email protected]> writes:\n>>\n>> > Somewhat related: I was wondering whether it would make sense for git.git\n>> > to rename `strbuf` to `git_buf`? Would that make it easier to exchange\n>> > code between the two projects? Or would it just be unnecessary churn?\n>>\n>> To us, \"git_buf\" is just as descriptive as \"buf\" and does not say\n>> anything about the nature of 'buf' (other than apparently it was\n>> invented and widely used here). \"git_strbuf\" I can understand, but\n>> why should we?\n>\n> If it makes code sharing between git.git and libgit2 easier, why shouldn't\n> we ;-)\n\nI see no reasonably explanation why libgit2 is not the one who uses\n\"#define strbuf git_buf\" to make \"sharing easier\", though.\n\n• ```* Re: [PATCH v2 05/13] reftable: utility functions\n2020-10-15 16:23 ` Junio C Hamano\n@ 2020-10-15 19:39 ` Johannes Schindelin\n2020-10-16 9:15 ` Patrick Steinhardt\n1 sibling, 0 replies; 251+ messages in thread\nFrom: Johannes Schindelin @ 2020-10-15 19:39 UTC (permalink / raw)\nTo: Junio C Hamano\nCc: Patrick Steinhardt, Jonathan Nieder, Han-Wen Nienhuys,\nHan-Wen Nienhuys via GitGitGadget, git, Jeff King,\nHan-Wen Nienhuys\n\nHi Junio,\n\nOn Thu, 15 Oct 2020, Junio C Hamano wrote:\n\n> Johannes Schindelin <[email protected]> writes:\n>\n> > Hi Junio,\n> >\n> > On Tue, 13 Oct 2020, Junio C Hamano wrote:\n> >\n> >> Johannes Schindelin <[email protected]> writes:\n> >>\n> >> > Somewhat related: I was wondering whether it would make sense for git.git\n> >> > to rename `strbuf` to `git_buf`? Would that make it easier to exchange\n> >> > code between the two projects? Or would it just be unnecessary churn?\n> >>\n> >> To us, \"git_buf\" is just as descriptive as \"buf\" and does not say\n> >> anything about the nature of 'buf' (other than apparently it was\n> >> invented and widely used here). \"git_strbuf\" I can understand, but\n> >> why should we?\n> >\n> > If it makes code sharing between git.git and libgit2 easier, why shouldn't\n> > we ;-)\n>\n> I see no reasonably explanation why libgit2 is not the one who uses\n> \"#define strbuf git_buf\" to make \"sharing easier\", though.\n\nThat's a fair point, thanks for bringing it up!\n\nCiao,\nDscho\n\n• ```* Re: [PATCH v2 05/13] reftable: utility functions\n2020-10-15 16:23 ` Junio C Hamano\n2020-10-15 19:39 ` Johannes Schindelin\n@ 2020-10-16 9:15 ` Patrick Steinhardt\n1 sibling, 0 replies; 251+ messages in thread\nFrom: Patrick Steinhardt @ 2020-10-16 9:15 UTC (permalink / raw)\nTo: Junio C Hamano\nCc: Johannes Schindelin, Jonathan Nieder, Han-Wen Nienhuys,\nHan-Wen Nienhuys via GitGitGadget, git, Jeff King,\nHan-Wen Nienhuys\n\n[-- Attachment #1: Type: text/plain, Size: 1245 bytes --]\n\nOn Thu, Oct 15, 2020 at 09:23:28AM -0700, Junio C Hamano wrote:\n> Johannes Schindelin <[email protected]> writes:\n>\n> > Hi Junio,\n> >\n> > On Tue, 13 Oct 2020, Junio C Hamano wrote:\n> >\n> >> Johannes Schindelin <[email protected]> writes:\n> >>\n> >> > Somewhat related: I was wondering whether it would make sense for git.git\n> >> > to rename `strbuf` to `git_buf`? Would that make it easier to exchange\n> >> > code between the two projects? Or would it just be unnecessary churn?\n> >>\n> >> To us, \"git_buf\" is just as descriptive as \"buf\" and does not say\n> >> anything about the nature of 'buf' (other than apparently it was\n> >> invented and widely used here). \"git_strbuf\" I can understand, but\n> >> why should we?\n> >\n> > If it makes code sharing between git.git and libgit2 easier, why shouldn't\n> > we ;-)\n>\n> I see no reasonably explanation why libgit2 is not the one who uses\n> \"#define strbuf git_buf\" to make \"sharing easier\", though.\n\nIt probably wouldn't help much anyway. We already have our own buffer\ntype which we can't easily replace with yours as it's part of the public\ninterface. If the need arises, providing a compatibility interface for\nit shouldn't be too hard.\n\nPatrick\n\n[-- Attachment #2: signature.asc --]\n[-- Type: application/pgp-signature, Size: 833 bytes --]\n\n• ```* Re: [PATCH v2 05/13] reftable: utility functions\n2020-10-01 16:10 ` [PATCH v2 05/13] reftable: utility functions Han-Wen Nienhuys via GitGitGadget\n2020-10-02 4:12 ` Jonathan Nieder\n@ 2020-10-02 14:01 ` Johannes Schindelin\n2020-10-02 20:47 ` Junio C Hamano\n2020-10-08 1:48 ` Jonathan Tan\nFrom: Johannes Schindelin @ 2020-10-02 14:01 UTC (permalink / raw)\nCc: git, Han-Wen Nienhuys, Jeff King, Han-Wen Nienhuys,\nHan-Wen Nienhuys, gitster\n\nHi Han-Wen,\n\nOn Thu, 1 Oct 2020, Han-Wen Nienhuys via GitGitGadget wrote:\n\n>\n> This commit provides basic utility classes for the reftable library.\n>\n> Since the reftable library must compile standalone, there may be some overlap\n> with git-core utility functions.\n\nMy position on this idea to duplicate functionality in order to somehow\npretend that the reftable code is independent of Git's source code has not\nchanged.\n\nBe that as it may, the CI build failures impacted my notifications'\nsignal/noise ratio too much, so here goes (Junio, I would be delighted if\nyou could apply this on top of your branch):\n\n-- snipsnap --\nFrom: Johannes Schindelin <[email protected]>\nDate: Wed, 30 Sep 2020 16:53:53 +0200\nSubject: [PATCH] fixup??? reftable: utility functions\n\nLet's not forget our CMake configuration.\n\nSigned-off-by: Johannes Schindelin <[email protected]>\n---\ncontrib/buildsystems/CMakeLists.txt | 14 ++++++++++++--\n1 file changed, 12 insertions(+), 2 deletions(-)\n\ndiff --git a/contrib/buildsystems/CMakeLists.txt b/contrib/buildsystems/CMakeLists.txt\n--- a/contrib/buildsystems/CMakeLists.txt\n+++ b/contrib/buildsystems/CMakeLists.txt\n@@ -591,6 +591,12 @@ parse_makefile_for_sources(libxdiff_SOURCES \"XDIFF_OBJS\")\nlist(TRANSFORM libxdiff_SOURCES PREPEND \"\\${CMAKE_SOURCE_DIR}/\")\n\n+#reftable\n+parse_makefile_for_sources(reftable_SOURCES \"REFTABLE_OBJS\")\n+\n+list(TRANSFORM reftable_SOURCES PREPEND \"\\${CMAKE_SOURCE_DIR}/\")\n+\nif(WIN32)\nif(NOT MSVC)#use windres when compiling with gcc and clang\n@@ -613,7 +619,7 @@ endif()\n#link all required libraries to common-main\n\nif(Intl_FOUND)\nendif()\n@@ -848,11 +854,15 @@ if(BUILD_TESTING)\n\n+#reftable-tests\n+parse_makefile_for_sources(test-reftable_SOURCES \"REFTABLE_TEST_OBJS\")\n+list(TRANSFORM test-reftable_SOURCES PREPEND \"\\${CMAKE_SOURCE_DIR}/\")\n+\n#test-tool\nparse_makefile_for_sources(test-tool_SOURCES \"TEST_BUILTINS_OBJS\")\n\nlist(TRANSFORM test-tool_SOURCES PREPEND \"\\${CMAKE_SOURCE_DIR}/t/helper/\")\n\nset_target_properties(test-fake-ssh test-tool\n--\n2.28.0.windows.1.18.g5300e52e185\n\n• ```* Re: [PATCH v2 05/13] reftable: utility functions\n2020-10-02 14:01 ` Johannes Schindelin\n@ 2020-10-02 20:47 ` Junio C Hamano\n2020-10-03 8:07 ` Johannes Schindelin\nFrom: Junio C Hamano @ 2020-10-02 20:47 UTC (permalink / raw)\nTo: Johannes Schindelin\nCc: Han-Wen Nienhuys via GitGitGadget, git, Han-Wen Nienhuys,\nJeff King, Han-Wen Nienhuys\n\nJohannes Schindelin <[email protected]> writes:\n\n>> This commit provides basic utility classes for the reftable library.\n>>\n>> Since the reftable library must compile standalone, there may be some overlap\n>> with git-core utility functions.\n>\n> My position on this idea to duplicate functionality in order to somehow\n> pretend that the reftable code is independent of Git's source code has not\n> changed.\n\nThe above may be sufficient between you and Han-Wen, and a few\nselected others who still remember, but please do not forget that we\nare collaborating in the open. It would help those who are learning\nopen source interactions by watching from sidelines, if you spelled\nout what your position is or at least left a pointer to a previous\ndiscussion.\n\nFWIW, I think it is a mistake to try to make this directory so that\nit can be lifted out of our code base and used independently, as it\nhas to create unnecessary friction to the code when used here. It\nis not like other code that we are not their primary intended\naudience and we simply \"borrow\" from them (e.g. xdiff/ & sha1dc/).\n\nThe previous paragraph agrees with my guess of your position, but\nperhaps you have something else in mind. I dunno.\n\n> Be that as it may, the CI build failures impacted my notifications'\n> signal/noise ratio too much, so here goes (Junio, I would be delighted if\n> you could apply this on top of your branch):\n\nQuite honestly, this close to the first preview release for 2.29,\nI'd rather drop this round from 'seen' and expect an updated topic,\nthan piling fixup on top of fixups.\n\nThanks.\n\n• ```* Re: [PATCH v2 05/13] reftable: utility functions\n2020-10-02 20:47 ` Junio C Hamano\n@ 2020-10-03 8:07 ` Johannes Schindelin\n0 siblings, 0 replies; 251+ messages in thread\nFrom: Johannes Schindelin @ 2020-10-03 8:07 UTC (permalink / raw)\nTo: Junio C Hamano\nCc: Han-Wen Nienhuys via GitGitGadget, git, Han-Wen Nienhuys,\nJeff King, Han-Wen Nienhuys\n\nHi Junio,\n\nOn Fri, 2 Oct 2020, Junio C Hamano wrote:\n\n> Johannes Schindelin <[email protected]> writes:\n>\n> >> This commit provides basic utility classes for the reftable library.\n> >>\n> >> Since the reftable library must compile standalone, there may be some overlap\n> >> with git-core utility functions.\n> >\n> > My position on this idea to duplicate functionality in order to somehow\n> > pretend that the reftable code is independent of Git's source code has not\n> > changed.\n>\n> The above may be sufficient between you and Han-Wen, and a few\n> selected others who still remember, but please do not forget that we\n> are collaborating in the open. It would help those who are learning\n> open source interactions by watching from sidelines, if you spelled\n> out what your position is or at least left a pointer to a previous\n> discussion.\n\nYou're right, sorry.\n\n> FWIW, I think it is a mistake to try to make this directory so that\n> it can be lifted out of our code base and used independently, as it\n> has to create unnecessary friction to the code when used here. It\n> is not like other code that we are not their primary intended\n> audience and we simply \"borrow\" from them (e.g. xdiff/ & sha1dc/).\n>\n> The previous paragraph agrees with my guess of your position, but\n> perhaps you have something else in mind. I dunno.\n\nYes, you were spot on.\n\nI am rather strongly opposed to introducing duplicated functionality.\nRather than spending time on finding half a dozen links to conversations\nin the past, let me try to make the case afresh:\n\nI have a very concrete example of the undesirable consequences: the\ncommit-graph breakage Stolee and I debugged yesterday, where a bug hid in\n`in_merge_bases_many()` for two years, hidden by the fact that there was\n_duplicate logic_ in `get_reachable_subset()`.\n\nPretty much _all_ of the code in `reftable/` is _very_ new, has not seen\nany real-world testing, and as such cannot really be trusted, in\nparticular the code that duplicates functionality already present in\nlibgit.a. Note that I do not claim that Han-Wen cannot be trusted: to the\ncontrary, I trust him very much (we have a history going all the way back\nto Lilypond, the musical typesetter). The code, however, cannot be\ntrusted, and needs to be reviewed and tested in practice.\n\nThe simple fact is that even the thorough review that the commit-graph\npatches received did not prevent the `min_generation`/`max_generation` bug\nin `in_merge_bases_many()` from entering the code base, and if we had not\nhad _another_ function doing very, very similar things, that bug would\nmost likely not have lingered for _this_ long.\n\nLikewise for the reimplementation of the convenient functionality like\n`strbuf`. This kind of duplication (in the case of `struct strbuf`, quite\n_literally_: there are now confusingly _two_ `strbuf.h` files that even\ntry to implement the _exact same_ API) is _prone_ to lead to stale, or\nlong undiscovered, bugs in one of the duplicated implementations.\n\nWhich means that we're likely to introduce bugs with those new functions\nintroduced in `reftable/`. For the reftable functionality, that has to be\naccepted. For functions that do the same as equivalents in libgit.a, we do\nnot have to accept it.\n\nIn any case, duplicated functionality is a maintenance burden, and\nespecially in this case, an unnecessary one at that: unlike xdiff or\ncompat/regex/, the reftable functionality is co-dependent with `libgit.a`.\nYes, you can implement libreftable as a stand-alone library (including\nduplicated functionality from libgit.a, as I pointed out), but you _cannot\nuse it independently of Git_.\n\nThe reftable concerns _Git_ refs.\n\nThis is not a compressor that could come in handy in a messenger app, or a\ndiff engine that could potentially help with a semantic merging tool.\n\nIt is code whose entire purpose is to manage boatloads of Git refs\nefficiently. Therefore, I see no convincing reason to insist on\nmaintaining this code outside of git/git.\n\nIt would make more sense to maintain parse-options or strbuf or\nt/test-lib.sh outside of git/git (because at least that functionality is\nindependent enough of Git to be potentially useful to other projects) and\nwe don't. We maintain them inside git/git, and for good reason: it makes\ndevelopment and maintenance a hell of a lot easier.\n\nAnd once we agree that reftable is intended to be so integral a part of\nGit that it should absolutely have its home inside git/git, all of that\nduplicated functionality (with almost totally untested implementations, at\nleast when it comes to \"battle testing in production\") can totally\nevaporate and does not need to worry us any more.\n\nAnd then we can start to spend reviewers' time on the actual code\nrevolving around the actual reftables rather than having to bother with\nreviewing, say, a close, but non-identical `strbuf` that might even have\n\"borrowed\" parts of the `strbuf` code and put it under a more permissive\nlicense (I don't know, and I don't want to know, that's part of the reason\nwhy I don't want to review the reftable patches in their current form).\n\nIn other words, we can then finally start to actually review the reftable\ncode on its merits of teaching Git a valuable new feature.\n\n> > Be that as it may, the CI build failures impacted my notifications'\n> > signal/noise ratio too much, so here goes (Junio, I would be delighted if\n> > you could apply this on top of your branch):\n>\n> Quite honestly, this close to the first preview release for 2.29,\n> I'd rather drop this round from 'seen' and expect an updated topic,\n> than piling fixup on top of fixups.\n\nSounds good to me.\n\nCiao,\nDscho\n\n• ```* Re: [PATCH v2 05/13] reftable: utility functions\n2020-10-01 16:10 ` [PATCH v2 05/13] reftable: utility functions Han-Wen Nienhuys via GitGitGadget\n2020-10-02 4:12 ` Jonathan Nieder\n2020-10-02 14:01 ` Johannes Schindelin\n@ 2020-10-08 1:48 ` Jonathan Tan\n2020-10-10 17:28 ` Han-Wen Nienhuys\nFrom: Jonathan Tan @ 2020-10-08 1:48 UTC (permalink / raw)\nTo: gitgitgadget; +Cc: git, hanwen, peff, hanwenn, Jonathan Tan\n\n>\n> This commit provides basic utility classes for the reftable library.\n>\n> Since the reftable library must compile standalone, there may be some overlap\n> with git-core utility functions.\n>\n> ---\n> Makefile | 26 ++++++-\n> reftable/basics.c | 131 +++++++++++++++++++++++++++++++++\n> reftable/basics.h | 48 +++++++++++++\n> reftable/blocksource.c | 148 ++++++++++++++++++++++++++++++++++++++\n> reftable/blocksource.h | 22 ++++++\n> reftable/compat.c | 110 ++++++++++++++++++++++++++++\n> reftable/compat.h | 48 +++++++++++++\n> reftable/publicbasics.c | 100 ++++++++++++++++++++++++++\n> reftable/reftable-tests.h | 22 ++++++\n> reftable/strbuf.c | 142 ++++++++++++++++++++++++++++++++++++\n> reftable/strbuf.h | 80 +++++++++++++++++++++\n> reftable/strbuf_test.c | 37 ++++++++++\n> reftable/system.h | 51 +++++++++++++\n> t/helper/test-reftable.c | 8 +++\n> t/helper/test-tool.c | 1 +\n> t/helper/test-tool.h | 1 +\n\nI think duplicating things like strbuf is an unnecessary burden if Git\nis to maintain this library. Something like \"reftable will only import\ngit-compat-util.h and strbuf.h, and any project that wants to use\nreftable must make sure that these functions and data structures are\navailable\" would be more plausible.\n\n• ```* Re: [PATCH v2 05/13] reftable: utility functions\n2020-10-08 1:48 ` Jonathan Tan\n@ 2020-10-10 17:28 ` Han-Wen Nienhuys\n2020-10-11 10:52 ` Johannes Schindelin\n2020-10-23 9:13 ` Ævar Arnfjörð Bjarmason\n0 siblings, 2 replies; 251+ messages in thread\nFrom: Han-Wen Nienhuys @ 2020-10-10 17:28 UTC (permalink / raw)\nTo: Jonathan Tan\nCc: Han-Wen Nienhuys via GitGitGadget, git, Jeff King, Han-Wen Nienhuys\n\nOn Thu, Oct 8, 2020 at 3:48 AM Jonathan Tan <[email protected]> wrote:\n>\n> > From: Han-Wen Nienhuys <[email protected]>\n> >\n> > This commit provides basic utility classes for the reftable library.\n> >\n> > Since the reftable library must compile standalone, there may be some overlap\n> > with git-core utility functions.\n\n> I think duplicating things like strbuf is an unnecessary burden if Git\n> is to maintain this library. Something like \"reftable will only import\n> git-compat-util.h and strbuf.h, and any project that wants to use\n> reftable must make sure that these functions and data structures are\n> available\" would be more plausible.\n\nSure, but how do we ensure that the directory won't take on\ndependencies beyond these headers? I am worried that I will be\ninvolved in a tedious back & forth process to keep updates going into\nlibgit2 and/or also have to keep maintaining\n\nFWIW, the duplication is really tiny: according to\n\n\\$ wc \\$(grep -l REFTABLE_STANDALONE *[ch])\n\nit's just 431 lines of code.\n\n--\nI work 80%. Don't expect answers from me on Fridays.\n--\nGoogle Germany GmbH, Erika-Mann-Strasse 33, 80636 Munich\nRegistergericht und -nummer: Hamburg, HRB 86891\nSitz der Gesellschaft: Hamburg\nGeschäftsführer: Paul Manicle, Halimah DeLaine Prado\n\n• ```* Re: [PATCH v2 05/13] reftable: utility functions\n2020-10-10 17:28 ` Han-Wen Nienhuys\n@ 2020-10-11 10:52 ` Johannes Schindelin\n2020-10-12 15:19 ` Jonathan Nieder\n2020-10-12 16:42 ` Junio C Hamano\n2020-10-23 9:13 ` Ævar Arnfjörð Bjarmason\n1 sibling, 2 replies; 251+ messages in thread\nFrom: Johannes Schindelin @ 2020-10-11 10:52 UTC (permalink / raw)\nTo: Han-Wen Nienhuys\nCc: Jonathan Tan, Han-Wen Nienhuys via GitGitGadget, git, Jeff King,\nHan-Wen Nienhuys\n\nHi Han-Wen,\n\nOn Sat, 10 Oct 2020, Han-Wen Nienhuys wrote:\n\n> On Thu, Oct 8, 2020 at 3:48 AM Jonathan Tan <[email protected]> wrote:\n> >\n> > > From: Han-Wen Nienhuys <[email protected]>\n> > >\n> > > This commit provides basic utility classes for the reftable library.\n> > >\n> > > Since the reftable library must compile standalone, there may be some overlap\n> > > with git-core utility functions.\n>\n> > I think duplicating things like strbuf is an unnecessary burden if Git\n> > is to maintain this library. Something like \"reftable will only import\n> > git-compat-util.h and strbuf.h, and any project that wants to use\n> > reftable must make sure that these functions and data structures are\n> > available\" would be more plausible.\n>\n> Sure, but how do we ensure that the directory won't take on\n> dependencies beyond these headers? I am worried that I will be\n> involved in a tedious back & forth process to keep updates going into\n> libgit2 and/or also have to keep maintaining\n>\n> FWIW, the duplication is really tiny: according to\n>\n> \\$ wc \\$(grep -l REFTABLE_STANDALONE *[ch])\n>\n> it's just 431 lines of code.\n\nThe `merge_bases_many()` function has only 33 lines of code, partially\nduplicating `get_reachable_subset()`. Yet, it had a bug in it for two\n\nHow much worse will the situation be with your 431 lines of code.\n\nEven more so when you consider the fact that you intend to shove the same\nduplication down libgit2's throat. It's \"triplicating\" code.\n\nSo I find the argument you made above quite unconvincing.\n\nCiao,\nDscho\n\n• ```* Re: [PATCH v2 05/13] reftable: utility functions\n2020-10-11 10:52 ` Johannes Schindelin\n@ 2020-10-12 15:19 ` Jonathan Nieder\n2020-10-12 18:44 ` Johannes Schindelin\n2020-10-12 16:42 ` Junio C Hamano\nFrom: Jonathan Nieder @ 2020-10-12 15:19 UTC (permalink / raw)\nTo: Johannes Schindelin\nCc: Han-Wen Nienhuys, Jonathan Tan,\nHan-Wen Nienhuys via GitGitGadget, git, Jeff King,\nHan-Wen Nienhuys\n\nHi,\n\nJohannes Schindelin wrote:\n\n> The `merge_bases_many()` function has only 33 lines of code, partially\n> duplicating `get_reachable_subset()`. Yet, it had a bug in it for two\n>\n> How much worse will the situation be with your 431 lines of code.\n>\n> Even more so when you consider the fact that you intend to shove the same\n> duplication down libgit2's throat. It's \"triplicating\" code.\n\nCareful: you seem to be making a bunch of assumptions here (for\nexample, around Han-Wen having some intent around shoving things down\nlibgit2's throat), and you seem to be focusing on the person instead\nof the contribution.\n\nWould you mind restating your point in a way that is a little easier\nto process, for example by focusing on the effect that this patch\nwould have on you as a Git developer?\n\nThanks,\nJonathan\n\n> So I find the argument you made above quite unconvincing.\n\n• ```* Re: [PATCH v2 05/13] reftable: utility functions\n2020-10-12 15:19 ` Jonathan Nieder\n@ 2020-10-12 18:44 ` Johannes Schindelin\n2020-10-12 19:41 ` Jonathan Nieder\nFrom: Johannes Schindelin @ 2020-10-12 18:44 UTC (permalink / raw)\nTo: Jonathan Nieder\nCc: Han-Wen Nienhuys, Jonathan Tan,\nHan-Wen Nienhuys via GitGitGadget, git, Jeff King,\nHan-Wen Nienhuys\n\n[-- Attachment #1: Type: text/plain, Size: 2367 bytes --]\n\nHi Jonathan,\n\nOn Mon, 12 Oct 2020, Jonathan Nieder wrote:\n\n> Johannes Schindelin wrote:\n>\n> > The `merge_bases_many()` function has only 33 lines of code, partially\n> > duplicating `get_reachable_subset()`. Yet, it had a bug in it for two\n> >\n> > How much worse will the situation be with your 431 lines of code.\n> >\n> > Even more so when you consider the fact that you intend to shove the same\n> > duplication down libgit2's throat. It's \"triplicating\" code.\n>\n> Careful: you seem to be making a bunch of assumptions here (for\n> example, around Han-Wen having some intent around shoving things down\n> libgit2's throat), and you seem to be focusing on the person instead\n> of the contribution.\n>\n> Would you mind restating your point in a way that is a little easier\n> to process, for example by focusing on the effect that this patch\n> would have on you as a Git developer?\n\nI really hope that Han-Wen did not take this as a personal attack.\n\nIn case he did, I'll gladly try to re-phrase my point: It does not matter\nhow much code is duplicated. The fact that we run into bugs even in\nunintentionally duplicated code is reason enough to not lightly accept\nthis design decision as being set in stone.\n\nWhich is why I, you, Emily and Josh pointed that out, and it is the same\nreason why Peff and Junio had made the same point in the past.\n\nI was quite unpleasantly surprised to see that all of those objections\nseemed to be insufficient, hence my rather forceful reply.\n\nAs to the libgit2 angle: libgit2 also has `strbuf` (which it calls\n`git_buf` IIRC), and I am certain that it also has those other helper\nfunctions à la `put_be32()`. So yes, the triplication I mentioned is a\nvery real, undesirable feature of this patch series.\n\nTo be honest, I would much rather spend my time reviewing patches that\nadded `reftable` support using as much of libgit.a's functionality as\npossible rather than repeating the same point over and over again: that it\nmakes very little sense _not_ to use that functionality. Of course, at\nthis stage I understand that my feedback is not very welcome, so I will\ntry to refrain from commenting on this patch series further (I do reserve\nthe right to send patches that fix CI failures, just like I've done quite\na few times up to this point).\n\nCiao,\nDscho\n\n• ```* Re: [PATCH v2 05/13] reftable: utility functions\n2020-10-12 18:44 ` Johannes Schindelin\n@ 2020-10-12 19:41 ` Jonathan Nieder\n2020-10-12 20:27 ` Johannes Schindelin\nFrom: Jonathan Nieder @ 2020-10-12 19:41 UTC (permalink / raw)\nTo: Johannes Schindelin\nCc: Han-Wen Nienhuys, Jonathan Tan,\nHan-Wen Nienhuys via GitGitGadget, git, Jeff King,\nHan-Wen Nienhuys\n\nJohannes Schindelin wrote:\n\n> Of course, at\n> this stage I understand that my feedback is not very welcome,\n\nDo you mean because you don't feel that your feedback has been\nsufficiently acted upon, or is there something else you are alluding\nto?\n\nPuzzled,\nJonathan\n\n• ```* Re: [PATCH v2 05/13] reftable: utility functions\n2020-10-12 19:41 ` Jonathan Nieder\n@ 2020-10-12 20:27 ` Johannes Schindelin\n0 siblings, 0 replies; 251+ messages in thread\nFrom: Johannes Schindelin @ 2020-10-12 20:27 UTC (permalink / raw)\nTo: Jonathan Nieder\nCc: Han-Wen Nienhuys, Jonathan Tan,\nHan-Wen Nienhuys via GitGitGadget, git, Jeff King,\nHan-Wen Nienhuys\n\nHi Jonathan,\n\nOn Mon, 12 Oct 2020, Jonathan Nieder wrote:\n\n> Johannes Schindelin wrote:\n>\n> > Of course, at this stage I understand that my feedback is not very\n> > welcome,\n>\n> Do you mean because you don't feel that your feedback has been\n> sufficiently acted upon, or is there something else you are alluding to?\n\nMy feedback has not been acted upon, and my arguments have been dismissed\n(or there were attempts to dismiss them, I should say, that did not\nconvince me). At least I saw that when gitster repeated some of my\nconcerns in #git-devel, there were attempts to address them. While I feel\nthat those concerns are being addressed.\n\nCiao,\nDscho\n\n• ```* Re: [PATCH v2 05/13] reftable: utility functions\n2020-10-11 10:52 ` Johannes Schindelin\n2020-10-12 15:19 ` Jonathan Nieder\n@ 2020-10-12 16:42 ` Junio C Hamano\n2020-10-12 19:01 ` Johannes Schindelin\nFrom: Junio C Hamano @ 2020-10-12 16:42 UTC (permalink / raw)\nTo: Johannes Schindelin\nCc: Han-Wen Nienhuys, Jonathan Tan,\nHan-Wen Nienhuys via GitGitGadget, git, Jeff King,\nHan-Wen Nienhuys\n\nJohannes Schindelin <[email protected]> writes:\n\n>> FWIW, the duplication is really tiny: according to\n>>\n>> \\$ wc \\$(grep -l REFTABLE_STANDALONE *[ch])\n>>\n>> it's just 431 lines of code.\n>\n> The `merge_bases_many()` function has only 33 lines of code, partially\n> duplicating `get_reachable_subset()`. Yet, it had a bug in it for two\n\nIt does not affect the current discussion, but what you are giving\nis a revisionist view of the world. The latter function came MUCH\nlater to do a bit more than the former. The bug was caused by the\nfact that those that added the latter neglected the responsibility\nof maintaining the former to the same degree when new feature like\ncommit-graph were added to the latter.\n\nThe root cause was that the latter one did not share the code with\nthe former one when it was introduced. That does make it appear\nsimilar to the situation we have at hand with duplicated utility\nfunctions.\n\n> How much worse will the situation be with your 431 lines of code.\n>\n> Even more so when you consider the fact that you intend to shove the same\n> duplication down libgit2's throat. It's \"triplicating\" code.\n>\n> So I find the argument you made above quite unconvincing.\n>\n> Ciao,\n> Dscho\n\n• ```* Re: [PATCH v2 05/13] reftable: utility functions\n2020-10-12 16:42 ` Junio C Hamano\n@ 2020-10-12 19:01 ` Johannes Schindelin\n0 siblings, 0 replies; 251+ messages in thread\nFrom: Johannes Schindelin @ 2020-10-12 19:01 UTC (permalink / raw)\nTo: Junio C Hamano\nCc: Han-Wen Nienhuys, Jonathan Tan,\nHan-Wen Nienhuys via GitGitGadget, git, Jeff King,\nHan-Wen Nienhuys\n\nHi Junio,\n\nOn Mon, 12 Oct 2020, Junio C Hamano wrote:\n\n> Johannes Schindelin <[email protected]> writes:\n>\n> >> FWIW, the duplication is really tiny: according to\n> >>\n> >> \\$ wc \\$(grep -l REFTABLE_STANDALONE *[ch])\n> >>\n> >> it's just 431 lines of code.\n> >\n> > The `merge_bases_many()` function has only 33 lines of code, partially\n> > duplicating `get_reachable_subset()`. Yet, it had a bug in it for two\n>\n> It does not affect the current discussion, but what you are giving\n> is a revisionist view of the world. The latter function came MUCH\n> later to do a bit more than the former. The bug was caused by the\n> fact that those that added the latter neglected the responsibility\n> of maintaining the former to the same degree when new feature like\n> commit-graph were added to the latter.\n\nYou're right, I mixed up the direction: by introducing new code, the old\ncode became under-tested and a bug creeped in that was not detected for\ntwo years.\n\n> The root cause was that the latter one did not share the code with\n> the former one when it was introduced. That does make it appear\n> similar to the situation we have at hand with duplicated utility\n> functions.\n\nIndeed, and even if this is just one concrete example, experience (and\nteachers and instructors and mentors) repeat the lesson that code\nduplication should be avoided because it _does_ cause problems.\n\nThanks for setting the record straight,\nDscho\n\n>\n> > How much worse will the situation be with your 431 lines of code.\n> >\n> > Even more so when you consider the fact that you intend to shove the same\n> > duplication down libgit2's throat. It's \"triplicating\" code.\n> >\n> > So I find the argument you made above quite unconvincing.\n> >\n> > Ciao,\n> > Dscho\n>\n\n• ```* Re: [PATCH v2 05/13] reftable: utility functions\n2020-10-10 17:28 ` Han-Wen Nienhuys\n2020-10-11 10:52 ` Johannes Schindelin\n@ 2020-10-23 9:13 ` Ævar Arnfjörð Bjarmason\n2020-10-23 17:36 ` Junio C Hamano\nFrom: Ævar Arnfjörð Bjarmason @ 2020-10-23 9:13 UTC (permalink / raw)\nTo: Han-Wen Nienhuys\nCc: Jonathan Tan, Han-Wen Nienhuys via GitGitGadget, git, Jeff King,\nHan-Wen Nienhuys, brian m. carlson\n\nOn Sat, Oct 10 2020, Han-Wen Nienhuys wrote:\n\n> On Thu, Oct 8, 2020 at 3:48 AM Jonathan Tan <[email protected]> wrote:\n>>\n>> > From: Han-Wen Nienhuys <[email protected]>\n>> >\n>> > This commit provides basic utility classes for the reftable library.\n>> >\n>> > Since the reftable library must compile standalone, there may be some overlap\n>> > with git-core utility functions.\n>\n>> I think duplicating things like strbuf is an unnecessary burden if Git\n>> is to maintain this library. Something like \"reftable will only import\n>> git-compat-util.h and strbuf.h, and any project that wants to use\n>> reftable must make sure that these functions and data structures are\n>> available\" would be more plausible.\n>\n> Sure, but how do we ensure that the directory won't take on\n> dependencies beyond these headers? I am worried that I will be\n> involved in a tedious back & forth process to keep updates going into\n> libgit2 and/or also have to keep maintaining\n>\n> FWIW, the duplication is really tiny: according to\n>\n> \\$ wc \\$(grep -l REFTABLE_STANDALONE *[ch])\n>\n> it's just 431 lines of code.\n\n# Not a general solution, but works for the specific code here.\nperl -0777 -pi -e 's[(#ifndef REFTABLE_STANDALONE\\n.*?\\n#else\\n).*?(?=\\n#endif)][\\$1/* Removed upstream code for git.git import */]gs' reftable/system.h\nperl -0777 -pi -e 's[(?<=#ifdef REFTABLE_STANDALONE\\n).*?(?=\\n#endif)][/* Removed upstream code for git.git import */]gs' reftable/strbuf.c reftable/compat.h\nperl -0777 -pi -e 's[(?<=#ifdef REFTABLE_STANDALONE\\n).*?(?=\\n#else)][/* Removed upstream code for git.git import */]gs' reftable/compat.c reftable/strbuf.h\n\nIt's now 157 lines instead of 431.\n\nI think doing that with a tiny bit more complexity in the update.sh\nscript is a much lower maintenance burden.\n\nIt's not just about the number of lines, but things coming up in grep,\nand now unique code really stands out (e.g. strbuf_add_void, should\nprobably be just added to the main strbuf.h if it's needed...), and of\ncourse the cost of attention of eyeballing an already big series on the\nML & the churn every time we have updates.\n\nOverall I'm all for having this carved out in its own directory at a\ncost of a bit more maintenance burden if it can be shared with libgit2 &\nbe a standalone library.\n\nI am concerned that it seems this code can't be maintained in git.git by\nanyone not willing to sign a contract with Google. I sent a tiny PR for\na typo fix at and got directed to sign before someone at Google\ncould look at it. I see brian raised this before in but there wasn't\n\nIs there some summary of how this part of integrating it is supposed to\nwork going forward?\n\nAt first glance that seems like a recipe for perma-forking this pretty\nmuch from day one, i.e.:\n\nA. Upstream changes happen\nB. We get a patch to the bundled library to this ML\n==> Google employees maintaining A can't even look at B\n==> Patch B can't be integrated into A\n\n3. https://lore.kernel.org/git/[email protected]/\n\n• ```* Re: [PATCH v2 05/13] reftable: utility functions\n2020-10-23 9:13 ` Ævar Arnfjörð Bjarmason\n@ 2020-10-23 17:36 ` Junio C Hamano\n0 siblings, 0 replies; 251+ messages in thread\nFrom: Junio C Hamano @ 2020-10-23 17:36 UTC (permalink / raw)\nTo: Ævar Arnfjörð Bjarmason\nCc: Han-Wen Nienhuys, Jonathan Tan,\nHan-Wen Nienhuys via GitGitGadget, git, Jeff King,\nHan-Wen Nienhuys, brian m. carlson\n\nÆvar Arnfjörð Bjarmason <[email protected]> writes:\n\n> It's not just about the number of lines, but things coming up in grep,\n> and now unique code really stands out (e.g. strbuf_add_void, should\n> probably be just added to the main strbuf.h if it's needed...), and of\n> course the cost of attention of eyeballing an already big series on the\n> ML & the churn every time we have updates.\n\nThese are all valid concerns.\n\n> Overall I'm all for having this carved out in its own directory at a\n> cost of a bit more maintenance burden if it can be shared with libgit2 &\n> be a standalone library.\n\nDo you mean by \"this\" the reftable stuff as a whole, or only the\nduplicated support library part? If the latter is split out of what\nwe import as our reftable/ directory, and stored in a separate\ndirectory that we do not have to import (because we have strbuf and\nother stuff) but other people may choose to use (because they may\nnot have strbuf and other stuff), that may work. Also, if the\ncontents of reftable/ directory wants a pluggable allocator, the\nmain code can be written to call reftable_malloc (or whatever), with\na thin shim to interface with us (i.e. reftable_malloc() would be\nimplemented as a thin wrapper around xmalloc() for us) which is\nstored in a separate directory just for us to interface with the\nmain reftable library. For libgit2, there will be a separate\ndirectory that uses a different implementation of reftable_malloc()\nthat would let them plug their preferred allocator. An arrangement\nlike that might work.\n\nI do not offhand know if that kind of overhead is worth the trouble\nor if there are better ways, though.\n\n> I am concerned that it seems this code can't be maintained in git.git by\n> anyone not willing to sign a contract with Google.\n\nIt can be maintained in git.git; the trouble comes when they want to\nupdate us.\n\nI however suspect that, as the primary intended audience, it is hard\nto imagine that the reftable library as a standalone project will be\nsuccessful without going through the usual reviews and testing in\ngit.git. So even though there exists github.com/google/reftable\nrepository, its contents may not matter very much in practice,\nunless they come here and beg for the change we make ourselves\nanyway. Perhaps I am being naive. I dunno.\n\n> I sent a tiny PR for\n> a typo fix at and got directed to sign before someone at Google\n> could look at it. I see brian raised this before in but there wasn't\n> a reply to that point.\n>\n> Is there some summary of how this part of integrating it is supposed to\n> work going forward?\n\nYeah, thanks for raising a good point. We definitely need to figure\nthis part out.\n\n> At first glance that seems like a recipe for perma-forking this pretty\n> much from day one, i.e.:\n>\n> A. Upstream changes happen\n> B. We get a patch to the bundled library to this ML\n> ==> Google employees maintaining A can't even look at B\n> ==> Patch B can't be integrated into A\n>\n> 3. https://lore.kernel.org/git/[email protected]/\n\n• ```* [PATCH v2 06/13] reftable: (de)serialization for the polymorphic record type.\n2020-10-01 16:10 ` [PATCH v2 00/13] reftable library Han-Wen Nienhuys via GitGitGadget\n` (4 preceding siblings ...)\n2020-10-01 16:10 ` [PATCH v2 05/13] reftable: utility functions Han-Wen Nienhuys via GitGitGadget\n@ 2020-10-01 16:10 ` Han-Wen Nienhuys via GitGitGadget\n2020-10-01 19:23 ` Junio C Hamano\n2020-10-01 16:10 ` [PATCH v2 07/13] reftable: reading/writing blocks Han-Wen Nienhuys via GitGitGadget\n` (7 subsequent siblings)\nFrom: Han-Wen Nienhuys via GitGitGadget @ 2020-10-01 16:10 UTC (permalink / raw)\nTo: git; +Cc: Han-Wen Nienhuys, Jeff King, Han-Wen Nienhuys, Han-Wen Nienhuys\n\n---\nMakefile | 2 +\nreftable/constants.h | 21 +\nreftable/record.c | 1116 ++++++++++++++++++++++++++++++++++++++\nreftable/record.h | 137 +++++\nreftable/record_test.c | 410 ++++++++++++++\nt/helper/test-reftable.c | 1 +\n6 files changed, 1687 insertions(+)\ncreate mode 100644 reftable/constants.h\ncreate mode 100644 reftable/record.c\ncreate mode 100644 reftable/record.h\ncreate mode 100644 reftable/record_test.c\n\ndiff --git a/Makefile b/Makefile\nindex e40d55cd87..b5e43d79ed 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -2376,8 +2376,10 @@ REFTABLE_OBJS += reftable/basics.o\nREFTABLE_OBJS += reftable/blocksource.o\nREFTABLE_OBJS += reftable/publicbasics.o\nREFTABLE_OBJS += reftable/compat.o\n+REFTABLE_OBJS += reftable/record.o\nREFTABLE_OBJS += reftable/strbuf.o\n\n+REFTABLE_TEST_OBJS += reftable/record_test.o\nREFTABLE_TEST_OBJS += reftable/strbuf_test.o\nREFTABLE_TEST_OBJS += reftable/test_framework.o\n\ndiff --git a/reftable/constants.h b/reftable/constants.h\nnew file mode 100644\nindex 0000000000..5eee72c4c1\n--- /dev/null\n+++ b/reftable/constants.h\n@@ -0,0 +1,21 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#ifndef CONSTANTS_H\n+#define CONSTANTS_H\n+\n+#define BLOCK_TYPE_LOG 'g'\n+#define BLOCK_TYPE_INDEX 'i'\n+#define BLOCK_TYPE_REF 'r'\n+#define BLOCK_TYPE_OBJ 'o'\n+#define BLOCK_TYPE_ANY 0\n+\n+#define MAX_RESTARTS ((1 << 16) - 1)\n+#define DEFAULT_BLOCK_SIZE 4096\n+\n+#endif\ndiff --git a/reftable/record.c b/reftable/record.c\nnew file mode 100644\nindex 0000000000..f050667ea4\n--- /dev/null\n+++ b/reftable/record.c\n@@ -0,0 +1,1116 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+/* record.c - methods for different types of records. */\n+\n+#include \"record.h\"\n+\n+#include \"system.h\"\n+#include \"constants.h\"\n+#include \"reftable.h\"\n+#include \"basics.h\"\n+\n+int get_var_int(uint64_t *dest, struct string_view *in)\n+{\n+\tint ptr = 0;\n+\tuint64_t val;\n+\n+\tif (in->len == 0)\n+\t\treturn -1;\n+\tval = in->buf[ptr] & 0x7f;\n+\n+\twhile (in->buf[ptr] & 0x80) {\n+\t\tptr++;\n+\t\tif (ptr > in->len) {\n+\t\t\treturn -1;\n+\t\t}\n+\t\tval = (val + 1) << 7 | (uint64_t)(in->buf[ptr] & 0x7f);\n+\t}\n+\n+\t*dest = val;\n+\treturn ptr + 1;\n+}\n+\n+int put_var_int(struct string_view *dest, uint64_t val)\n+{\n+\tuint8_t buf = { 0 };\n+\tint i = 9;\n+\tint n = 0;\n+\tbuf[i] = (uint8_t)(val & 0x7f);\n+\ti--;\n+\twhile (1) {\n+\t\tval >>= 7;\n+\t\tif (!val) {\n+\t\t\tbreak;\n+\t\t}\n+\t\tval--;\n+\t\tbuf[i] = 0x80 | (uint8_t)(val & 0x7f);\n+\t\ti--;\n+\t}\n+\n+\tn = sizeof(buf) - i - 1;\n+\tif (dest->len < n)\n+\t\treturn -1;\n+\tmemcpy(dest->buf, &buf[i + 1], n);\n+\treturn n;\n+}\n+\n+int reftable_is_block_type(uint8_t typ)\n+{\n+\tswitch (typ) {\n+\tcase BLOCK_TYPE_REF:\n+\tcase BLOCK_TYPE_LOG:\n+\tcase BLOCK_TYPE_OBJ:\n+\tcase BLOCK_TYPE_INDEX:\n+\t\treturn 1;\n+\t}\n+\treturn 0;\n+}\n+\n+static int decode_string(struct strbuf *dest, struct string_view in)\n+{\n+\tint start_len = in.len;\n+\tuint64_t tsize = 0;\n+\tint n = get_var_int(&tsize, &in);\n+\tif (n <= 0)\n+\t\treturn -1;\n+\tstring_view_consume(&in, n);\n+\tif (in.len < tsize)\n+\t\treturn -1;\n+\n+\tstrbuf_reset(dest);\n+\tstring_view_consume(&in, tsize);\n+\n+\treturn start_len - in.len;\n+}\n+\n+static int encode_string(char *str, struct string_view s)\n+{\n+\tstruct string_view start = s;\n+\tint l = strlen(str);\n+\tint n = put_var_int(&s, l);\n+\tif (n < 0)\n+\t\treturn -1;\n+\tstring_view_consume(&s, n);\n+\tif (s.len < l)\n+\t\treturn -1;\n+\tmemcpy(s.buf, str, l);\n+\tstring_view_consume(&s, l);\n+\n+\treturn start.len - s.len;\n+}\n+\n+int reftable_encode_key(int *restart, struct string_view dest,\n+\t\t\tstruct strbuf prev_key, struct strbuf key,\n+\t\t\tuint8_t extra)\n+{\n+\tstruct string_view start = dest;\n+\tint prefix_len = common_prefix_size(&prev_key, &key);\n+\tuint64_t suffix_len = key.len - prefix_len;\n+\tint n = put_var_int(&dest, (uint64_t)prefix_len);\n+\tif (n < 0)\n+\t\treturn -1;\n+\tstring_view_consume(&dest, n);\n+\n+\t*restart = (prefix_len == 0);\n+\n+\tn = put_var_int(&dest, suffix_len << 3 | (uint64_t)extra);\n+\tif (n < 0)\n+\t\treturn -1;\n+\tstring_view_consume(&dest, n);\n+\n+\tif (dest.len < suffix_len)\n+\t\treturn -1;\n+\tmemcpy(dest.buf, key.buf + prefix_len, suffix_len);\n+\tstring_view_consume(&dest, suffix_len);\n+\n+\treturn start.len - dest.len;\n+}\n+\n+int reftable_decode_key(struct strbuf *key, uint8_t *extra,\n+\t\t\tstruct strbuf last_key, struct string_view in)\n+{\n+\tint start_len = in.len;\n+\tuint64_t prefix_len = 0;\n+\tuint64_t suffix_len = 0;\n+\tint n = get_var_int(&prefix_len, &in);\n+\tif (n < 0)\n+\t\treturn -1;\n+\tstring_view_consume(&in, n);\n+\n+\tif (prefix_len > last_key.len)\n+\t\treturn -1;\n+\n+\tn = get_var_int(&suffix_len, &in);\n+\tif (n <= 0)\n+\t\treturn -1;\n+\tstring_view_consume(&in, n);\n+\n+\t*extra = (uint8_t)(suffix_len & 0x7);\n+\tsuffix_len >>= 3;\n+\n+\tif (in.len < suffix_len)\n+\t\treturn -1;\n+\n+\tstrbuf_reset(key);\n+\tstring_view_consume(&in, suffix_len);\n+\n+\treturn start_len - in.len;\n+}\n+\n+static void reftable_ref_record_key(const void *r, struct strbuf *dest)\n+{\n+\tconst struct reftable_ref_record *rec =\n+\t\t(const struct reftable_ref_record *)r;\n+\tstrbuf_reset(dest);\n+}\n+\n+static void reftable_ref_record_copy_from(void *rec, const void *src_rec,\n+\t\t\t\t\t int hash_size)\n+{\n+\tstruct reftable_ref_record *ref = (struct reftable_ref_record *)rec;\n+\tstruct reftable_ref_record *src = (struct reftable_ref_record *)src_rec;\n+\tassert(hash_size > 0);\n+\n+\t/* This is simple and correct, but we could probably reuse the hash\n+\t fields. */\n+\treftable_ref_record_clear(ref);\n+\tif (src->refname != NULL) {\n+\t\tref->refname = xstrdup(src->refname);\n+\t}\n+\n+\tif (src->target != NULL) {\n+\t\tref->target = xstrdup(src->target);\n+\t}\n+\n+\tif (src->target_value != NULL) {\n+\t\tref->target_value = reftable_malloc(hash_size);\n+\t\tmemcpy(ref->target_value, src->target_value, hash_size);\n+\t}\n+\n+\tif (src->value != NULL) {\n+\t\tref->value = reftable_malloc(hash_size);\n+\t\tmemcpy(ref->value, src->value, hash_size);\n+\t}\n+\tref->update_index = src->update_index;\n+}\n+\n+static char hexdigit(int c)\n+{\n+\tif (c <= 9)\n+\t\treturn '0' + c;\n+\treturn 'a' + (c - 10);\n+}\n+\n+static void hex_format(char *dest, uint8_t *src, int hash_size)\n+{\n+\tassert(hash_size > 0);\n+\tif (src != NULL) {\n+\t\tint i = 0;\n+\t\tfor (i = 0; i < hash_size; i++) {\n+\t\t\tdest[2 * i] = hexdigit(src[i] >> 4);\n+\t\t\tdest[2 * i + 1] = hexdigit(src[i] & 0xf);\n+\t\t}\n+\t\tdest[2 * hash_size] = 0;\n+\t}\n+}\n+\n+void reftable_ref_record_print(struct reftable_ref_record *ref,\n+\t\t\t uint32_t hash_id)\n+{\n+\tchar hex[SHA256_SIZE + 1] = { 0 };\n+\tprintf(\"ref{%s(%\" PRIu64 \") \", ref->refname, ref->update_index);\n+\tif (ref->value != NULL) {\n+\t\thex_format(hex, ref->value, hash_size(hash_id));\n+\t\tprintf(\"%s\", hex);\n+\t}\n+\tif (ref->target_value != NULL) {\n+\t\thex_format(hex, ref->target_value, hash_size(hash_id));\n+\t\tprintf(\" (T %s)\", hex);\n+\t}\n+\tif (ref->target != NULL) {\n+\t\tprintf(\"=> %s\", ref->target);\n+\t}\n+\tprintf(\"}\\n\");\n+}\n+\n+static void reftable_ref_record_clear_void(void *rec)\n+{\n+\treftable_ref_record_clear((struct reftable_ref_record *)rec);\n+}\n+\n+void reftable_ref_record_clear(struct reftable_ref_record *ref)\n+{\n+\treftable_free(ref->refname);\n+\treftable_free(ref->target);\n+\treftable_free(ref->target_value);\n+\treftable_free(ref->value);\n+\tmemset(ref, 0, sizeof(struct reftable_ref_record));\n+}\n+\n+static uint8_t reftable_ref_record_val_type(const void *rec)\n+{\n+\tconst struct reftable_ref_record *r =\n+\t\t(const struct reftable_ref_record *)rec;\n+\tif (r->value != NULL) {\n+\t\tif (r->target_value != NULL) {\n+\t\t\treturn 2;\n+\t\t} else {\n+\t\t\treturn 1;\n+\t\t}\n+\t} else if (r->target != NULL)\n+\t\treturn 3;\n+\treturn 0;\n+}\n+\n+static int reftable_ref_record_encode(const void *rec, struct string_view s,\n+\t\t\t\t int hash_size)\n+{\n+\tconst struct reftable_ref_record *r =\n+\t\t(const struct reftable_ref_record *)rec;\n+\tstruct string_view start = s;\n+\tint n = put_var_int(&s, r->update_index);\n+\tassert(hash_size > 0);\n+\tif (n < 0)\n+\t\treturn -1;\n+\tstring_view_consume(&s, n);\n+\n+\tif (r->value != NULL) {\n+\t\tif (s.len < hash_size) {\n+\t\t\treturn -1;\n+\t\t}\n+\t\tmemcpy(s.buf, r->value, hash_size);\n+\t\tstring_view_consume(&s, hash_size);\n+\t}\n+\n+\tif (r->target_value != NULL) {\n+\t\tif (s.len < hash_size) {\n+\t\t\treturn -1;\n+\t\t}\n+\t\tmemcpy(s.buf, r->target_value, hash_size);\n+\t\tstring_view_consume(&s, hash_size);\n+\t}\n+\n+\tif (r->target != NULL) {\n+\t\tint n = encode_string(r->target, s);\n+\t\tif (n < 0) {\n+\t\t\treturn -1;\n+\t\t}\n+\t\tstring_view_consume(&s, n);\n+\t}\n+\n+\treturn start.len - s.len;\n+}\n+\n+static int reftable_ref_record_decode(void *rec, struct strbuf key,\n+\t\t\t\t uint8_t val_type, struct string_view in,\n+\t\t\t\t int hash_size)\n+{\n+\tstruct reftable_ref_record *r = (struct reftable_ref_record *)rec;\n+\tstruct string_view start = in;\n+\tint seen_value = 0;\n+\tint seen_target_value = 0;\n+\tint seen_target = 0;\n+\n+\tint n = get_var_int(&r->update_index, &in);\n+\tif (n < 0)\n+\t\treturn n;\n+\tassert(hash_size > 0);\n+\n+\tstring_view_consume(&in, n);\n+\n+\tr->refname = reftable_realloc(r->refname, key.len + 1);\n+\tmemcpy(r->refname, key.buf, key.len);\n+\tr->refname[key.len] = 0;\n+\n+\tswitch (val_type) {\n+\tcase 1:\n+\tcase 2:\n+\t\tif (in.len < hash_size) {\n+\t\t\treturn -1;\n+\t\t}\n+\n+\t\tif (r->value == NULL) {\n+\t\t\tr->value = reftable_malloc(hash_size);\n+\t\t}\n+\t\tseen_value = 1;\n+\t\tmemcpy(r->value, in.buf, hash_size);\n+\t\tstring_view_consume(&in, hash_size);\n+\t\tif (val_type == 1) {\n+\t\t\tbreak;\n+\t\t}\n+\t\tif (r->target_value == NULL) {\n+\t\t\tr->target_value = reftable_malloc(hash_size);\n+\t\t}\n+\t\tseen_target_value = 1;\n+\t\tmemcpy(r->target_value, in.buf, hash_size);\n+\t\tstring_view_consume(&in, hash_size);\n+\t\tbreak;\n+\tcase 3: {\n+\t\tstruct strbuf dest = STRBUF_INIT;\n+\t\tint n = decode_string(&dest, in);\n+\t\tif (n < 0) {\n+\t\t\treturn -1;\n+\t\t}\n+\t\tstring_view_consume(&in, n);\n+\t\tseen_target = 1;\n+\t\tif (r->target != NULL) {\n+\t\t\treftable_free(r->target);\n+\t\t}\n+\t\tr->target = dest.buf;\n+\t} break;\n+\n+\tcase 0:\n+\t\tbreak;\n+\tdefault:\n+\t\tabort();\n+\t\tbreak;\n+\t}\n+\n+\tif (!seen_target && r->target != NULL) {\n+\t\tFREE_AND_NULL(r->target);\n+\t}\n+\tif (!seen_target_value && r->target_value != NULL) {\n+\t\tFREE_AND_NULL(r->target_value);\n+\t}\n+\tif (!seen_value && r->value != NULL) {\n+\t\tFREE_AND_NULL(r->value);\n+\t}\n+\n+\treturn start.len - in.len;\n+}\n+\n+static int reftable_ref_record_is_deletion_void(const void *p)\n+{\n+\treturn reftable_ref_record_is_deletion(\n+\t\t(const struct reftable_ref_record *)p);\n+}\n+\n+static struct reftable_record_vtable reftable_ref_record_vtable = {\n+\t.key = &reftable_ref_record_key,\n+\t.type = BLOCK_TYPE_REF,\n+\t.copy_from = &reftable_ref_record_copy_from,\n+\t.val_type = &reftable_ref_record_val_type,\n+\t.encode = &reftable_ref_record_encode,\n+\t.decode = &reftable_ref_record_decode,\n+\t.clear = &reftable_ref_record_clear_void,\n+\t.is_deletion = &reftable_ref_record_is_deletion_void,\n+};\n+\n+static void reftable_obj_record_key(const void *r, struct strbuf *dest)\n+{\n+\tconst struct reftable_obj_record *rec =\n+\t\t(const struct reftable_obj_record *)r;\n+\tstrbuf_reset(dest);\n+}\n+\n+static void reftable_obj_record_clear(void *rec)\n+{\n+\tstruct reftable_obj_record *obj = (struct reftable_obj_record *)rec;\n+\tFREE_AND_NULL(obj->hash_prefix);\n+\tFREE_AND_NULL(obj->offsets);\n+\tmemset(obj, 0, sizeof(struct reftable_obj_record));\n+}\n+\n+static void reftable_obj_record_copy_from(void *rec, const void *src_rec,\n+\t\t\t\t\t int hash_size)\n+{\n+\tstruct reftable_obj_record *obj = (struct reftable_obj_record *)rec;\n+\tconst struct reftable_obj_record *src =\n+\t\t(const struct reftable_obj_record *)src_rec;\n+\tint olen;\n+\n+\treftable_obj_record_clear(obj);\n+\t*obj = *src;\n+\tobj->hash_prefix = reftable_malloc(obj->hash_prefix_len);\n+\tmemcpy(obj->hash_prefix, src->hash_prefix, obj->hash_prefix_len);\n+\n+\tolen = obj->offset_len * sizeof(uint64_t);\n+\tobj->offsets = reftable_malloc(olen);\n+\tmemcpy(obj->offsets, src->offsets, olen);\n+}\n+\n+static uint8_t reftable_obj_record_val_type(const void *rec)\n+{\n+\tstruct reftable_obj_record *r = (struct reftable_obj_record *)rec;\n+\tif (r->offset_len > 0 && r->offset_len < 8)\n+\t\treturn r->offset_len;\n+\treturn 0;\n+}\n+\n+static int reftable_obj_record_encode(const void *rec, struct string_view s,\n+\t\t\t\t int hash_size)\n+{\n+\tstruct reftable_obj_record *r = (struct reftable_obj_record *)rec;\n+\tstruct string_view start = s;\n+\tint i = 0;\n+\tint n = 0;\n+\tuint64_t last = 0;\n+\tif (r->offset_len == 0 || r->offset_len >= 8) {\n+\t\tn = put_var_int(&s, r->offset_len);\n+\t\tif (n < 0) {\n+\t\t\treturn -1;\n+\t\t}\n+\t\tstring_view_consume(&s, n);\n+\t}\n+\tif (r->offset_len == 0)\n+\t\treturn start.len - s.len;\n+\tn = put_var_int(&s, r->offsets);\n+\tif (n < 0)\n+\t\treturn -1;\n+\tstring_view_consume(&s, n);\n+\n+\tlast = r->offsets;\n+\tfor (i = 1; i < r->offset_len; i++) {\n+\t\tint n = put_var_int(&s, r->offsets[i] - last);\n+\t\tif (n < 0) {\n+\t\t\treturn -1;\n+\t\t}\n+\t\tstring_view_consume(&s, n);\n+\t\tlast = r->offsets[i];\n+\t}\n+\treturn start.len - s.len;\n+}\n+\n+static int reftable_obj_record_decode(void *rec, struct strbuf key,\n+\t\t\t\t uint8_t val_type, struct string_view in,\n+\t\t\t\t int hash_size)\n+{\n+\tstruct string_view start = in;\n+\tstruct reftable_obj_record *r = (struct reftable_obj_record *)rec;\n+\tuint64_t count = val_type;\n+\tint n = 0;\n+\tuint64_t last;\n+\tint j;\n+\tr->hash_prefix = reftable_malloc(key.len);\n+\tmemcpy(r->hash_prefix, key.buf, key.len);\n+\tr->hash_prefix_len = key.len;\n+\n+\tif (val_type == 0) {\n+\t\tn = get_var_int(&count, &in);\n+\t\tif (n < 0) {\n+\t\t\treturn n;\n+\t\t}\n+\n+\t\tstring_view_consume(&in, n);\n+\t}\n+\n+\tr->offsets = NULL;\n+\tr->offset_len = 0;\n+\tif (count == 0)\n+\t\treturn start.len - in.len;\n+\n+\tr->offsets = reftable_malloc(count * sizeof(uint64_t));\n+\tr->offset_len = count;\n+\n+\tn = get_var_int(&r->offsets, &in);\n+\tif (n < 0)\n+\t\treturn n;\n+\tstring_view_consume(&in, n);\n+\n+\tlast = r->offsets;\n+\tj = 1;\n+\twhile (j < count) {\n+\t\tuint64_t delta = 0;\n+\t\tint n = get_var_int(&delta, &in);\n+\t\tif (n < 0) {\n+\t\t\treturn n;\n+\t\t}\n+\t\tstring_view_consume(&in, n);\n+\n+\t\tlast = r->offsets[j] = (delta + last);\n+\t\tj++;\n+\t}\n+\treturn start.len - in.len;\n+}\n+\n+static int not_a_deletion(const void *p)\n+{\n+\treturn 0;\n+}\n+\n+static struct reftable_record_vtable reftable_obj_record_vtable = {\n+\t.key = &reftable_obj_record_key,\n+\t.type = BLOCK_TYPE_OBJ,\n+\t.copy_from = &reftable_obj_record_copy_from,\n+\t.val_type = &reftable_obj_record_val_type,\n+\t.encode = &reftable_obj_record_encode,\n+\t.decode = &reftable_obj_record_decode,\n+\t.clear = &reftable_obj_record_clear,\n+\t.is_deletion = not_a_deletion,\n+};\n+\n+void reftable_log_record_print(struct reftable_log_record *log,\n+\t\t\t uint32_t hash_id)\n+{\n+\tchar hex[SHA256_SIZE + 1] = { 0 };\n+\n+\tprintf(\"log{%s(%\" PRIu64 \") %s <%s> %\" PRIu64 \" %04d\\n\", log->refname,\n+\t log->update_index, log->name, log->email, log->time,\n+\t log->tz_offset);\n+\thex_format(hex, log->old_hash, hash_size(hash_id));\n+\tprintf(\"%s => \", hex);\n+\thex_format(hex, log->new_hash, hash_size(hash_id));\n+\tprintf(\"%s\\n\\n%s\\n}\\n\", hex, log->message);\n+}\n+\n+static void reftable_log_record_key(const void *r, struct strbuf *dest)\n+{\n+\tconst struct reftable_log_record *rec =\n+\t\t(const struct reftable_log_record *)r;\n+\tint len = strlen(rec->refname);\n+\tuint8_t i64;\n+\tuint64_t ts = 0;\n+\tstrbuf_reset(dest);\n+\tstrbuf_add(dest, (uint8_t *)rec->refname, len + 1);\n+\n+\tts = (~ts) - rec->update_index;\n+\tput_be64(&i64, ts);\n+}\n+\n+static void reftable_log_record_copy_from(void *rec, const void *src_rec,\n+\t\t\t\t\t int hash_size)\n+{\n+\tstruct reftable_log_record *dst = (struct reftable_log_record *)rec;\n+\tconst struct reftable_log_record *src =\n+\t\t(const struct reftable_log_record *)src_rec;\n+\n+\treftable_log_record_clear(dst);\n+\t*dst = *src;\n+\tif (dst->refname != NULL) {\n+\t\tdst->refname = xstrdup(dst->refname);\n+\t}\n+\tif (dst->email != NULL) {\n+\t\tdst->email = xstrdup(dst->email);\n+\t}\n+\tif (dst->name != NULL) {\n+\t\tdst->name = xstrdup(dst->name);\n+\t}\n+\tif (dst->message != NULL) {\n+\t\tdst->message = xstrdup(dst->message);\n+\t}\n+\n+\tif (dst->new_hash != NULL) {\n+\t\tdst->new_hash = reftable_malloc(hash_size);\n+\t\tmemcpy(dst->new_hash, src->new_hash, hash_size);\n+\t}\n+\tif (dst->old_hash != NULL) {\n+\t\tdst->old_hash = reftable_malloc(hash_size);\n+\t\tmemcpy(dst->old_hash, src->old_hash, hash_size);\n+\t}\n+}\n+\n+static void reftable_log_record_clear_void(void *rec)\n+{\n+\tstruct reftable_log_record *r = (struct reftable_log_record *)rec;\n+\treftable_log_record_clear(r);\n+}\n+\n+void reftable_log_record_clear(struct reftable_log_record *r)\n+{\n+\treftable_free(r->refname);\n+\treftable_free(r->new_hash);\n+\treftable_free(r->old_hash);\n+\treftable_free(r->name);\n+\treftable_free(r->email);\n+\treftable_free(r->message);\n+\tmemset(r, 0, sizeof(struct reftable_log_record));\n+}\n+\n+static uint8_t reftable_log_record_val_type(const void *rec)\n+{\n+\tconst struct reftable_log_record *log =\n+\t\t(const struct reftable_log_record *)rec;\n+\n+\treturn reftable_log_record_is_deletion(log) ? 0 : 1;\n+}\n+\n+static uint8_t zero[SHA256_SIZE] = { 0 };\n+\n+static int reftable_log_record_encode(const void *rec, struct string_view s,\n+\t\t\t\t int hash_size)\n+{\n+\tstruct reftable_log_record *r = (struct reftable_log_record *)rec;\n+\tstruct string_view start = s;\n+\tint n = 0;\n+\tuint8_t *oldh = r->old_hash;\n+\tuint8_t *newh = r->new_hash;\n+\tif (reftable_log_record_is_deletion(r))\n+\t\treturn 0;\n+\n+\tif (oldh == NULL) {\n+\t\toldh = zero;\n+\t}\n+\tif (newh == NULL) {\n+\t\tnewh = zero;\n+\t}\n+\n+\tif (s.len < 2 * hash_size)\n+\t\treturn -1;\n+\n+\tmemcpy(s.buf, oldh, hash_size);\n+\tmemcpy(s.buf + hash_size, newh, hash_size);\n+\tstring_view_consume(&s, 2 * hash_size);\n+\n+\tn = encode_string(r->name ? r->name : \"\", s);\n+\tif (n < 0)\n+\t\treturn -1;\n+\tstring_view_consume(&s, n);\n+\n+\tn = encode_string(r->email ? r->email : \"\", s);\n+\tif (n < 0)\n+\t\treturn -1;\n+\tstring_view_consume(&s, n);\n+\n+\tn = put_var_int(&s, r->time);\n+\tif (n < 0)\n+\t\treturn -1;\n+\tstring_view_consume(&s, n);\n+\n+\tif (s.len < 2)\n+\t\treturn -1;\n+\n+\tput_be16(s.buf, r->tz_offset);\n+\tstring_view_consume(&s, 2);\n+\n+\tn = encode_string(r->message ? r->message : \"\", s);\n+\tif (n < 0)\n+\t\treturn -1;\n+\tstring_view_consume(&s, n);\n+\n+\treturn start.len - s.len;\n+}\n+\n+static int reftable_log_record_decode(void *rec, struct strbuf key,\n+\t\t\t\t uint8_t val_type, struct string_view in,\n+\t\t\t\t int hash_size)\n+{\n+\tstruct string_view start = in;\n+\tstruct reftable_log_record *r = (struct reftable_log_record *)rec;\n+\tuint64_t max = 0;\n+\tuint64_t ts = 0;\n+\tstruct strbuf dest = STRBUF_INIT;\n+\tint n;\n+\n+\tif (key.len <= 9 || key.buf[key.len - 9] != 0)\n+\t\treturn REFTABLE_FORMAT_ERROR;\n+\n+\tr->refname = reftable_realloc(r->refname, key.len - 8);\n+\tmemcpy(r->refname, key.buf, key.len - 8);\n+\tts = get_be64(key.buf + key.len - 8);\n+\n+\tr->update_index = (~max) - ts;\n+\n+\tif (val_type == 0) {\n+\t\tFREE_AND_NULL(r->old_hash);\n+\t\tFREE_AND_NULL(r->new_hash);\n+\t\tFREE_AND_NULL(r->message);\n+\t\tFREE_AND_NULL(r->email);\n+\t\tFREE_AND_NULL(r->name);\n+\t\treturn 0;\n+\t}\n+\n+\tif (in.len < 2 * hash_size)\n+\t\treturn REFTABLE_FORMAT_ERROR;\n+\n+\tr->old_hash = reftable_realloc(r->old_hash, hash_size);\n+\tr->new_hash = reftable_realloc(r->new_hash, hash_size);\n+\n+\tmemcpy(r->old_hash, in.buf, hash_size);\n+\tmemcpy(r->new_hash, in.buf + hash_size, hash_size);\n+\n+\tstring_view_consume(&in, 2 * hash_size);\n+\n+\tn = decode_string(&dest, in);\n+\tif (n < 0)\n+\t\tgoto done;\n+\tstring_view_consume(&in, n);\n+\n+\tr->name = reftable_realloc(r->name, dest.len + 1);\n+\tmemcpy(r->name, dest.buf, dest.len);\n+\tr->name[dest.len] = 0;\n+\n+\tstrbuf_reset(&dest);\n+\tn = decode_string(&dest, in);\n+\tif (n < 0)\n+\t\tgoto done;\n+\tstring_view_consume(&in, n);\n+\n+\tr->email = reftable_realloc(r->email, dest.len + 1);\n+\tmemcpy(r->email, dest.buf, dest.len);\n+\tr->email[dest.len] = 0;\n+\n+\tts = 0;\n+\tn = get_var_int(&ts, &in);\n+\tif (n < 0)\n+\t\tgoto done;\n+\tstring_view_consume(&in, n);\n+\tr->time = ts;\n+\tif (in.len < 2)\n+\t\tgoto done;\n+\n+\tr->tz_offset = get_be16(in.buf);\n+\tstring_view_consume(&in, 2);\n+\n+\tstrbuf_reset(&dest);\n+\tn = decode_string(&dest, in);\n+\tif (n < 0)\n+\t\tgoto done;\n+\tstring_view_consume(&in, n);\n+\n+\tr->message = reftable_realloc(r->message, dest.len + 1);\n+\tmemcpy(r->message, dest.buf, dest.len);\n+\tr->message[dest.len] = 0;\n+\n+\tstrbuf_release(&dest);\n+\treturn start.len - in.len;\n+\n+done:\n+\tstrbuf_release(&dest);\n+\treturn REFTABLE_FORMAT_ERROR;\n+}\n+\n+static int null_streq(char *a, char *b)\n+{\n+\tchar *empty = \"\";\n+\tif (a == NULL)\n+\t\ta = empty;\n+\n+\tif (b == NULL)\n+\t\tb = empty;\n+\n+\treturn 0 == strcmp(a, b);\n+}\n+\n+static int zero_hash_eq(uint8_t *a, uint8_t *b, int sz)\n+{\n+\tif (a == NULL)\n+\t\ta = zero;\n+\n+\tif (b == NULL)\n+\t\tb = zero;\n+\n+\treturn !memcmp(a, b, sz);\n+}\n+\n+int reftable_log_record_equal(struct reftable_log_record *a,\n+\t\t\t struct reftable_log_record *b, int hash_size)\n+{\n+\treturn null_streq(a->name, b->name) && null_streq(a->email, b->email) &&\n+\t null_streq(a->message, b->message) &&\n+\t zero_hash_eq(a->old_hash, b->old_hash, hash_size) &&\n+\t zero_hash_eq(a->new_hash, b->new_hash, hash_size) &&\n+\t a->time == b->time && a->tz_offset == b->tz_offset &&\n+\t a->update_index == b->update_index;\n+}\n+\n+static int reftable_log_record_is_deletion_void(const void *p)\n+{\n+\treturn reftable_log_record_is_deletion(\n+\t\t(const struct reftable_log_record *)p);\n+}\n+\n+static struct reftable_record_vtable reftable_log_record_vtable = {\n+\t.key = &reftable_log_record_key,\n+\t.type = BLOCK_TYPE_LOG,\n+\t.copy_from = &reftable_log_record_copy_from,\n+\t.val_type = &reftable_log_record_val_type,\n+\t.encode = &reftable_log_record_encode,\n+\t.decode = &reftable_log_record_decode,\n+\t.clear = &reftable_log_record_clear_void,\n+\t.is_deletion = &reftable_log_record_is_deletion_void,\n+};\n+\n+struct reftable_record reftable_new_record(uint8_t typ)\n+{\n+\tstruct reftable_record rec = { NULL };\n+\tswitch (typ) {\n+\tcase BLOCK_TYPE_REF: {\n+\t\tstruct reftable_ref_record *r =\n+\t\t\treftable_calloc(sizeof(struct reftable_ref_record));\n+\t\treftable_record_from_ref(&rec, r);\n+\t\treturn rec;\n+\t}\n+\n+\tcase BLOCK_TYPE_OBJ: {\n+\t\tstruct reftable_obj_record *r =\n+\t\t\treftable_calloc(sizeof(struct reftable_obj_record));\n+\t\treftable_record_from_obj(&rec, r);\n+\t\treturn rec;\n+\t}\n+\tcase BLOCK_TYPE_LOG: {\n+\t\tstruct reftable_log_record *r =\n+\t\t\treftable_calloc(sizeof(struct reftable_log_record));\n+\t\treftable_record_from_log(&rec, r);\n+\t\treturn rec;\n+\t}\n+\tcase BLOCK_TYPE_INDEX: {\n+\t\tstruct reftable_index_record empty = { .last_key =\n+\t\t\t\t\t\t\t STRBUF_INIT };\n+\t\tstruct reftable_index_record *r =\n+\t\t\treftable_calloc(sizeof(struct reftable_index_record));\n+\t\t*r = empty;\n+\t\treftable_record_from_index(&rec, r);\n+\t\treturn rec;\n+\t}\n+\t}\n+\tabort();\n+\treturn rec;\n+}\n+\n+/* clear out the record, yielding the reftable_record data that was\n+ * encapsulated. */\n+static void *reftable_record_yield(struct reftable_record *rec)\n+{\n+\tvoid *p = rec->data;\n+\trec->data = NULL;\n+\treturn p;\n+}\n+\n+void reftable_record_destroy(struct reftable_record *rec)\n+{\n+\treftable_record_clear(rec);\n+\treftable_free(reftable_record_yield(rec));\n+}\n+\n+static void reftable_index_record_key(const void *r, struct strbuf *dest)\n+{\n+\tstruct reftable_index_record *rec = (struct reftable_index_record *)r;\n+\tstrbuf_reset(dest);\n+}\n+\n+static void reftable_index_record_copy_from(void *rec, const void *src_rec,\n+\t\t\t\t\t int hash_size)\n+{\n+\tstruct reftable_index_record *dst = (struct reftable_index_record *)rec;\n+\tstruct reftable_index_record *src =\n+\t\t(struct reftable_index_record *)src_rec;\n+\n+\tstrbuf_reset(&dst->last_key);\n+\tdst->offset = src->offset;\n+}\n+\n+static void reftable_index_record_clear(void *rec)\n+{\n+\tstruct reftable_index_record *idx = (struct reftable_index_record *)rec;\n+\tstrbuf_release(&idx->last_key);\n+}\n+\n+static uint8_t reftable_index_record_val_type(const void *rec)\n+{\n+\treturn 0;\n+}\n+\n+static int reftable_index_record_encode(const void *rec, struct string_view out,\n+\t\t\t\t\tint hash_size)\n+{\n+\tconst struct reftable_index_record *r =\n+\t\t(const struct reftable_index_record *)rec;\n+\tstruct string_view start = out;\n+\n+\tint n = put_var_int(&out, r->offset);\n+\tif (n < 0)\n+\t\treturn n;\n+\n+\tstring_view_consume(&out, n);\n+\n+\treturn start.len - out.len;\n+}\n+\n+static int reftable_index_record_decode(void *rec, struct strbuf key,\n+\t\t\t\t\tuint8_t val_type, struct string_view in,\n+\t\t\t\t\tint hash_size)\n+{\n+\tstruct string_view start = in;\n+\tstruct reftable_index_record *r = (struct reftable_index_record *)rec;\n+\tint n = 0;\n+\n+\tstrbuf_reset(&r->last_key);\n+\n+\tn = get_var_int(&r->offset, &in);\n+\tif (n < 0)\n+\t\treturn n;\n+\n+\tstring_view_consume(&in, n);\n+\treturn start.len - in.len;\n+}\n+\n+static struct reftable_record_vtable reftable_index_record_vtable = {\n+\t.key = &reftable_index_record_key,\n+\t.type = BLOCK_TYPE_INDEX,\n+\t.copy_from = &reftable_index_record_copy_from,\n+\t.val_type = &reftable_index_record_val_type,\n+\t.encode = &reftable_index_record_encode,\n+\t.decode = &reftable_index_record_decode,\n+\t.clear = &reftable_index_record_clear,\n+\t.is_deletion = &not_a_deletion,\n+};\n+\n+void reftable_record_key(struct reftable_record *rec, struct strbuf *dest)\n+{\n+\trec->ops->key(rec->data, dest);\n+}\n+\n+uint8_t reftable_record_type(struct reftable_record *rec)\n+{\n+\treturn rec->ops->type;\n+}\n+\n+int reftable_record_encode(struct reftable_record *rec, struct string_view dest,\n+\t\t\t int hash_size)\n+{\n+\treturn rec->ops->encode(rec->data, dest, hash_size);\n+}\n+\n+void reftable_record_copy_from(struct reftable_record *rec,\n+\t\t\t struct reftable_record *src, int hash_size)\n+{\n+\tassert(src->ops->type == rec->ops->type);\n+\n+\trec->ops->copy_from(rec->data, src->data, hash_size);\n+}\n+\n+uint8_t reftable_record_val_type(struct reftable_record *rec)\n+{\n+\treturn rec->ops->val_type(rec->data);\n+}\n+\n+int reftable_record_decode(struct reftable_record *rec, struct strbuf key,\n+\t\t\t uint8_t extra, struct string_view src, int hash_size)\n+{\n+\treturn rec->ops->decode(rec->data, key, extra, src, hash_size);\n+}\n+\n+void reftable_record_clear(struct reftable_record *rec)\n+{\n+\trec->ops->clear(rec->data);\n+}\n+\n+int reftable_record_is_deletion(struct reftable_record *rec)\n+{\n+\treturn rec->ops->is_deletion(rec->data);\n+}\n+\n+void reftable_record_from_ref(struct reftable_record *rec,\n+\t\t\t struct reftable_ref_record *ref_rec)\n+{\n+\tassert(rec->ops == NULL);\n+\trec->data = ref_rec;\n+\trec->ops = &reftable_ref_record_vtable;\n+}\n+\n+void reftable_record_from_obj(struct reftable_record *rec,\n+\t\t\t struct reftable_obj_record *obj_rec)\n+{\n+\tassert(rec->ops == NULL);\n+\trec->data = obj_rec;\n+\trec->ops = &reftable_obj_record_vtable;\n+}\n+\n+void reftable_record_from_index(struct reftable_record *rec,\n+\t\t\t\tstruct reftable_index_record *index_rec)\n+{\n+\tassert(rec->ops == NULL);\n+\trec->data = index_rec;\n+\trec->ops = &reftable_index_record_vtable;\n+}\n+\n+void reftable_record_from_log(struct reftable_record *rec,\n+\t\t\t struct reftable_log_record *log_rec)\n+{\n+\tassert(rec->ops == NULL);\n+\trec->data = log_rec;\n+\trec->ops = &reftable_log_record_vtable;\n+}\n+\n+struct reftable_ref_record *reftable_record_as_ref(struct reftable_record *rec)\n+{\n+\tassert(reftable_record_type(rec) == BLOCK_TYPE_REF);\n+\treturn (struct reftable_ref_record *)rec->data;\n+}\n+\n+struct reftable_log_record *reftable_record_as_log(struct reftable_record *rec)\n+{\n+\tassert(reftable_record_type(rec) == BLOCK_TYPE_LOG);\n+\treturn (struct reftable_log_record *)rec->data;\n+}\n+\n+static int hash_equal(uint8_t *a, uint8_t *b, int hash_size)\n+{\n+\tif (a != NULL && b != NULL)\n+\t\treturn !memcmp(a, b, hash_size);\n+\n+\treturn a == b;\n+}\n+\n+static int str_equal(char *a, char *b)\n+{\n+\tif (a != NULL && b != NULL)\n+\t\treturn 0 == strcmp(a, b);\n+\n+\treturn a == b;\n+}\n+\n+int reftable_ref_record_equal(struct reftable_ref_record *a,\n+\t\t\t struct reftable_ref_record *b, int hash_size)\n+{\n+\tassert(hash_size > 0);\n+\treturn 0 == strcmp(a->refname, b->refname) &&\n+\t a->update_index == b->update_index &&\n+\t hash_equal(a->value, b->value, hash_size) &&\n+\t hash_equal(a->target_value, b->target_value, hash_size) &&\n+\t str_equal(a->target, b->target);\n+}\n+\n+int reftable_ref_record_compare_name(const void *a, const void *b)\n+{\n+\treturn strcmp(((struct reftable_ref_record *)a)->refname,\n+\t\t ((struct reftable_ref_record *)b)->refname);\n+}\n+\n+int reftable_ref_record_is_deletion(const struct reftable_ref_record *ref)\n+{\n+\treturn ref->value == NULL && ref->target == NULL &&\n+\t ref->target_value == NULL;\n+}\n+\n+int reftable_log_record_compare_key(const void *a, const void *b)\n+{\n+\tstruct reftable_log_record *la = (struct reftable_log_record *)a;\n+\tstruct reftable_log_record *lb = (struct reftable_log_record *)b;\n+\n+\tint cmp = strcmp(la->refname, lb->refname);\n+\tif (cmp)\n+\t\treturn cmp;\n+\tif (la->update_index > lb->update_index)\n+\t\treturn -1;\n+\treturn (la->update_index < lb->update_index) ? 1 : 0;\n+}\n+\n+int reftable_log_record_is_deletion(const struct reftable_log_record *log)\n+{\n+\treturn (log->new_hash == NULL && log->old_hash == NULL &&\n+\t\tlog->name == NULL && log->email == NULL &&\n+\t\tlog->message == NULL && log->time == 0 && log->tz_offset == 0 &&\n+\t\tlog->message == NULL);\n+}\n+\n+void string_view_consume(struct string_view *s, int n)\n+{\n+\ts->buf += n;\n+\ts->len -= n;\n+}\ndiff --git a/reftable/record.h b/reftable/record.h\nnew file mode 100644\nindex 0000000000..dd5881ed75\n--- /dev/null\n+++ b/reftable/record.h\n@@ -0,0 +1,137 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#ifndef RECORD_H\n+#define RECORD_H\n+\n+#include \"reftable.h\"\n+#include \"strbuf.h\"\n+#include \"system.h\"\n+\n+/*\n+ A substring of existing string data. This structure takes no responsibility\n+ for the lifetime of the data it points to.\n+*/\n+struct string_view {\n+\tuint8_t *buf;\n+\tsize_t len;\n+};\n+\n+/* Advance `s.buf` by `n`, and decrease length. */\n+void string_view_consume(struct string_view *s, int n);\n+\n+/* utilities for de/encoding varints */\n+\n+int get_var_int(uint64_t *dest, struct string_view *in);\n+int put_var_int(struct string_view *dest, uint64_t val);\n+\n+/* Methods for records. */\n+struct reftable_record_vtable {\n+\t/* encode the key of to a uint8_t strbuf. */\n+\tvoid (*key)(const void *rec, struct strbuf *dest);\n+\n+\t/* The record type of ('r' for ref). */\n+\tuint8_t type;\n+\n+\tvoid (*copy_from)(void *dest, const void *src, int hash_size);\n+\n+\t/* a value of [0..7], indicating record subvariants (eg. ref vs. symref\n+\t * vs ref deletion) */\n+\tuint8_t (*val_type)(const void *rec);\n+\n+\t/* encodes rec into dest, returning how much space was used. */\n+\tint (*encode)(const void *rec, struct string_view dest, int hash_size);\n+\n+\t/* decode data from `src` into the record. */\n+\tint (*decode)(void *rec, struct strbuf key, uint8_t extra,\n+\t\t struct string_view src, int hash_size);\n+\n+\t/* deallocate and null the record. */\n+\tvoid (*clear)(void *rec);\n+\n+\t/* is this a tombstone? */\n+\tint (*is_deletion)(const void *rec);\n+};\n+\n+/* record is a generic wrapper for different types of records. */\n+struct reftable_record {\n+\tvoid *data;\n+\tstruct reftable_record_vtable *ops;\n+};\n+\n+/* returns true for recognized block types. Block start with the block type. */\n+int reftable_is_block_type(uint8_t typ);\n+\n+/* creates a malloced record of the given type. Dispose with record_destroy */\n+struct reftable_record reftable_new_record(uint8_t typ);\n+\n+/* Encode `key` into `dest`. Sets `is_restart` to indicate a restart. Returns\n+ number of bytes written. */\n+int reftable_encode_key(int *is_restart, struct string_view dest,\n+\t\t\tstruct strbuf prev_key, struct strbuf key,\n+\t\t\tuint8_t extra);\n+\n+/* Decode into `key` and `extra` from `in` */\n+int reftable_decode_key(struct strbuf *key, uint8_t *extra,\n+\t\t\tstruct strbuf last_key, struct string_view in);\n+\n+/* reftable_index_record are used internally to speed up lookups. */\n+struct reftable_index_record {\n+\tuint64_t offset; /* Offset of block */\n+\tstruct strbuf last_key; /* Last key of the block. */\n+};\n+\n+/* reftable_obj_record stores an object ID => ref mapping. */\n+struct reftable_obj_record {\n+\tuint8_t *hash_prefix; /* leading bytes of the object ID */\n+\tint hash_prefix_len; /* number of leading bytes. Constant\n+\t\t\t * across a single table. */\n+\tuint64_t *offsets; /* a vector of file offsets. */\n+\tint offset_len;\n+};\n+\n+/* see struct record_vtable */\n+\n+void reftable_record_key(struct reftable_record *rec, struct strbuf *dest);\n+uint8_t reftable_record_type(struct reftable_record *rec);\n+void reftable_record_copy_from(struct reftable_record *rec,\n+\t\t\t struct reftable_record *src, int hash_size);\n+uint8_t reftable_record_val_type(struct reftable_record *rec);\n+int reftable_record_encode(struct reftable_record *rec, struct string_view dest,\n+\t\t\t int hash_size);\n+int reftable_record_decode(struct reftable_record *rec, struct strbuf key,\n+\t\t\t uint8_t extra, struct string_view src,\n+\t\t\t int hash_size);\n+int reftable_record_is_deletion(struct reftable_record *rec);\n+\n+/* zeroes out the embedded record */\n+void reftable_record_clear(struct reftable_record *rec);\n+\n+/* clear and deallocate embedded record, and zero `rec`. */\n+void reftable_record_destroy(struct reftable_record *rec);\n+\n+/* initialize generic records from concrete records. The generic record should\n+ * be zeroed out. */\n+void reftable_record_from_obj(struct reftable_record *rec,\n+\t\t\t struct reftable_obj_record *objrec);\n+void reftable_record_from_index(struct reftable_record *rec,\n+\t\t\t\tstruct reftable_index_record *idxrec);\n+void reftable_record_from_ref(struct reftable_record *rec,\n+\t\t\t struct reftable_ref_record *refrec);\n+void reftable_record_from_log(struct reftable_record *rec,\n+\t\t\t struct reftable_log_record *logrec);\n+struct reftable_ref_record *reftable_record_as_ref(struct reftable_record *ref);\n+struct reftable_log_record *reftable_record_as_log(struct reftable_record *ref);\n+\n+/* for qsort. */\n+int reftable_ref_record_compare_name(const void *a, const void *b);\n+\n+/* for qsort. */\n+int reftable_log_record_compare_key(const void *a, const void *b);\n+\n+#endif\ndiff --git a/reftable/record_test.c b/reftable/record_test.c\nnew file mode 100644\nindex 0000000000..dcf1c74cb7\n--- /dev/null\n+++ b/reftable/record_test.c\n@@ -0,0 +1,410 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"record.h\"\n+\n+#include \"system.h\"\n+#include \"basics.h\"\n+#include \"constants.h\"\n+#include \"reftable.h\"\n+#include \"test_framework.h\"\n+#include \"reftable-tests.h\"\n+\n+static void test_copy(struct reftable_record *rec)\n+{\n+\tstruct reftable_record copy =\n+\t\treftable_new_record(reftable_record_type(rec));\n+\treftable_record_copy_from(&copy, rec, SHA1_SIZE);\n+\t/* do it twice to catch memory leaks */\n+\treftable_record_copy_from(&copy, rec, SHA1_SIZE);\n+\tswitch (reftable_record_type(&copy)) {\n+\tcase BLOCK_TYPE_REF:\n+\t\tassert(reftable_ref_record_equal(reftable_record_as_ref(&copy),\n+\t\t\t\t\t\t reftable_record_as_ref(rec),\n+\t\t\t\t\t\t SHA1_SIZE));\n+\t\tbreak;\n+\tcase BLOCK_TYPE_LOG:\n+\t\tassert(reftable_log_record_equal(reftable_record_as_log(&copy),\n+\t\t\t\t\t\t reftable_record_as_log(rec),\n+\t\t\t\t\t\t SHA1_SIZE));\n+\t\tbreak;\n+\t}\n+\treftable_record_destroy(&copy);\n+}\n+\n+static void test_varint_roundtrip(void)\n+{\n+\tuint64_t inputs[] = { 0,\n+\t\t\t 1,\n+\t\t\t 27,\n+\t\t\t 127,\n+\t\t\t 128,\n+\t\t\t 257,\n+\t\t\t 4096,\n+\t\t\t ((uint64_t)1 << 63),\n+\t\t\t ((uint64_t)1 << 63) + ((uint64_t)1 << 63) - 1 };\n+\tint i = 0;\n+\tfor (i = 0; i < ARRAY_SIZE(inputs); i++) {\n+\t\tuint8_t dest;\n+\n+\t\tstruct string_view out = {\n+\t\t\t.buf = dest,\n+\t\t\t.len = sizeof(dest),\n+\t\t};\n+\t\tuint64_t in = inputs[i];\n+\t\tint n = put_var_int(&out, in);\n+\t\tuint64_t got = 0;\n+\n+\t\tassert(n > 0);\n+\t\tout.len = n;\n+\t\tn = get_var_int(&got, &out);\n+\t\tassert(n > 0);\n+\n+\t\tassert(got == in);\n+\t}\n+}\n+\n+static void test_common_prefix(void)\n+{\n+\tstruct {\n+\t\tconst char *a, *b;\n+\t\tint want;\n+\t} cases[] = {\n+\t\t{ \"abc\", \"ab\", 2 },\n+\t\t{ \"\", \"abc\", 0 },\n+\t\t{ \"abc\", \"abd\", 2 },\n+\t\t{ \"abc\", \"pqr\", 0 },\n+\t};\n+\n+\tint i = 0;\n+\tfor (i = 0; i < ARRAY_SIZE(cases); i++) {\n+\t\tstruct strbuf a = STRBUF_INIT;\n+\t\tstruct strbuf b = STRBUF_INIT;\n+\t\tassert(common_prefix_size(&a, &b) == cases[i].want);\n+\n+\t\tstrbuf_release(&a);\n+\t\tstrbuf_release(&b);\n+\t}\n+}\n+\n+static void set_hash(uint8_t *h, int j)\n+{\n+\tint i = 0;\n+\tfor (i = 0; i < hash_size(SHA1_ID); i++) {\n+\t\th[i] = (j >> i) & 0xff;\n+\t}\n+}\n+\n+static void test_reftable_ref_record_roundtrip(void)\n+{\n+\tint i = 0;\n+\n+\tfor (i = 0; i <= 3; i++) {\n+\t\tstruct reftable_ref_record in = { NULL };\n+\t\tstruct reftable_ref_record out = {\n+\t\t\t.refname = xstrdup(\"old name\"),\n+\t\t\t.value = reftable_calloc(SHA1_SIZE),\n+\t\t\t.target_value = reftable_calloc(SHA1_SIZE),\n+\t\t\t.target = xstrdup(\"old value\"),\n+\t\t};\n+\t\tstruct reftable_record rec_out = { NULL };\n+\t\tstruct strbuf key = STRBUF_INIT;\n+\t\tstruct reftable_record rec = { NULL };\n+\t\tuint8_t buffer = { 0 };\n+\t\tstruct string_view dest = {\n+\t\t\t.buf = buffer,\n+\t\t\t.len = sizeof(buffer),\n+\t\t};\n+\n+\t\tint n, m;\n+\n+\t\tswitch (i) {\n+\t\tcase 0:\n+\t\t\tbreak;\n+\t\tcase 1:\n+\t\t\tin.value = reftable_malloc(SHA1_SIZE);\n+\t\t\tset_hash(in.value, 1);\n+\t\t\tbreak;\n+\t\tcase 2:\n+\t\t\tin.value = reftable_malloc(SHA1_SIZE);\n+\t\t\tset_hash(in.value, 1);\n+\t\t\tin.target_value = reftable_malloc(SHA1_SIZE);\n+\t\t\tset_hash(in.target_value, 2);\n+\t\t\tbreak;\n+\t\tcase 3:\n+\t\t\tin.target = xstrdup(\"target\");\n+\t\t\tbreak;\n+\t\t}\n+\n+\t\treftable_record_from_ref(&rec, &in);\n+\t\ttest_copy(&rec);\n+\n+\t\tassert(reftable_record_val_type(&rec) == i);\n+\n+\t\treftable_record_key(&rec, &key);\n+\t\tn = reftable_record_encode(&rec, dest, SHA1_SIZE);\n+\t\tassert(n > 0);\n+\n+\t\t/* decode into a non-zero reftable_record to test for leaks. */\n+\n+\t\treftable_record_from_ref(&rec_out, &out);\n+\t\tm = reftable_record_decode(&rec_out, key, i, dest, SHA1_SIZE);\n+\t\tassert(n == m);\n+\n+\t\tassert((out.value != NULL) == (in.value != NULL));\n+\t\tassert((out.target_value != NULL) == (in.target_value != NULL));\n+\t\tassert((out.target != NULL) == (in.target != NULL));\n+\t\treftable_record_clear(&rec_out);\n+\n+\t\tstrbuf_release(&key);\n+\t\treftable_ref_record_clear(&in);\n+\t}\n+}\n+\n+static void test_reftable_log_record_equal(void)\n+{\n+\tstruct reftable_log_record in = {\n+\t\t{\n+\t\t\t.update_index = 42,\n+\t\t},\n+\t\t{\n+\t\t\t.update_index = 22,\n+\t\t}\n+\t};\n+\n+\tassert(!reftable_log_record_equal(&in, &in, SHA1_SIZE));\n+\tin.update_index = in.update_index;\n+\tassert(reftable_log_record_equal(&in, &in, SHA1_SIZE));\n+\treftable_log_record_clear(&in);\n+\treftable_log_record_clear(&in);\n+}\n+\n+static void test_reftable_log_record_roundtrip(void)\n+{\n+\tstruct reftable_log_record in = {\n+\t\t{\n+\t\t\t.old_hash = reftable_malloc(SHA1_SIZE),\n+\t\t\t.new_hash = reftable_malloc(SHA1_SIZE),\n+\t\t\t.name = xstrdup(\"han-wen\"),\n+\t\t\t.message = xstrdup(\"test\"),\n+\t\t\t.update_index = 42,\n+\t\t\t.time = 1577123507,\n+\t\t\t.tz_offset = 100,\n+\t\t},\n+\t\t{\n+\t\t\t.update_index = 22,\n+\t\t}\n+\t};\n+\tset_test_hash(in.new_hash, 1);\n+\tset_test_hash(in.old_hash, 2);\n+\tfor (int i = 0; i < ARRAY_SIZE(in); i++) {\n+\t\tstruct reftable_record rec = { NULL };\n+\t\tstruct strbuf key = STRBUF_INIT;\n+\t\tuint8_t buffer = { 0 };\n+\t\tstruct string_view dest = {\n+\t\t\t.buf = buffer,\n+\t\t\t.len = sizeof(buffer),\n+\t\t};\n+\t\t/* populate out, to check for leaks. */\n+\t\tstruct reftable_log_record out = {\n+\t\t\t.refname = xstrdup(\"old name\"),\n+\t\t\t.new_hash = reftable_calloc(SHA1_SIZE),\n+\t\t\t.old_hash = reftable_calloc(SHA1_SIZE),\n+\t\t\t.name = xstrdup(\"old name\"),\n+\t\t\t.email = xstrdup(\"old@email\"),\n+\t\t\t.message = xstrdup(\"old message\"),\n+\t\t};\n+\t\tstruct reftable_record rec_out = { NULL };\n+\t\tint n, m, valtype;\n+\n+\t\treftable_record_from_log(&rec, &in[i]);\n+\n+\t\ttest_copy(&rec);\n+\n+\t\treftable_record_key(&rec, &key);\n+\n+\t\tn = reftable_record_encode(&rec, dest, SHA1_SIZE);\n+\t\tassert(n >= 0);\n+\t\treftable_record_from_log(&rec_out, &out);\n+\t\tvaltype = reftable_record_val_type(&rec);\n+\t\tm = reftable_record_decode(&rec_out, key, valtype, dest,\n+\t\t\t\t\t SHA1_SIZE);\n+\t\tassert(n == m);\n+\n+\t\tassert(reftable_log_record_equal(&in[i], &out, SHA1_SIZE));\n+\t\treftable_log_record_clear(&in[i]);\n+\t\tstrbuf_release(&key);\n+\t\treftable_record_clear(&rec_out);\n+\t}\n+}\n+\n+static void test_u24_roundtrip(void)\n+{\n+\tuint32_t in = 0x112233;\n+\tuint8_t dest;\n+\tuint32_t out;\n+\tput_be24(dest, in);\n+\tout = get_be24(dest);\n+\tassert(in == out);\n+}\n+\n+static void test_key_roundtrip(void)\n+{\n+\tuint8_t buffer = { 0 };\n+\tstruct string_view dest = {\n+\t\t.buf = buffer,\n+\t\t.len = sizeof(buffer),\n+\t};\n+\tstruct strbuf last_key = STRBUF_INIT;\n+\tstruct strbuf key = STRBUF_INIT;\n+\tstruct strbuf roundtrip = STRBUF_INIT;\n+\tint restart;\n+\tuint8_t extra;\n+\tint n, m;\n+\tuint8_t rt_extra;\n+\n+\textra = 6;\n+\tn = reftable_encode_key(&restart, dest, last_key, key, extra);\n+\tassert(!restart);\n+\tassert(n > 0);\n+\n+\tm = reftable_decode_key(&roundtrip, &rt_extra, last_key, dest);\n+\tassert(n == m);\n+\tassert(0 == strbuf_cmp(&key, &roundtrip));\n+\tassert(rt_extra == extra);\n+\n+\tstrbuf_release(&last_key);\n+\tstrbuf_release(&key);\n+\tstrbuf_release(&roundtrip);\n+}\n+\n+static void test_reftable_obj_record_roundtrip(void)\n+{\n+\tuint8_t testHash1[SHA1_SIZE] = { 1, 2, 3, 4, 0 };\n+\tuint64_t till9[] = { 1, 2, 3, 4, 500, 600, 700, 800, 9000 };\n+\tstruct reftable_obj_record recs = { {\n+\t\t\t\t\t\t .hash_prefix = testHash1,\n+\t\t\t\t\t\t .hash_prefix_len = 5,\n+\t\t\t\t\t\t .offsets = till9,\n+\t\t\t\t\t\t .offset_len = 3,\n+\t\t\t\t\t },\n+\t\t\t\t\t {\n+\t\t\t\t\t\t .hash_prefix = testHash1,\n+\t\t\t\t\t\t .hash_prefix_len = 5,\n+\t\t\t\t\t\t .offsets = till9,\n+\t\t\t\t\t\t .offset_len = 9,\n+\t\t\t\t\t },\n+\t\t\t\t\t {\n+\t\t\t\t\t\t .hash_prefix = testHash1,\n+\t\t\t\t\t\t .hash_prefix_len = 5,\n+\t\t\t\t\t } };\n+\tint i = 0;\n+\tfor (i = 0; i < ARRAY_SIZE(recs); i++) {\n+\t\tstruct reftable_obj_record in = recs[i];\n+\t\tuint8_t buffer = { 0 };\n+\t\tstruct string_view dest = {\n+\t\t\t.buf = buffer,\n+\t\t\t.len = sizeof(buffer),\n+\t\t};\n+\t\tstruct reftable_record rec = { NULL };\n+\t\tstruct strbuf key = STRBUF_INIT;\n+\t\tstruct reftable_obj_record out = { NULL };\n+\t\tstruct reftable_record rec_out = { NULL };\n+\t\tint n, m;\n+\t\tuint8_t extra;\n+\n+\t\treftable_record_from_obj(&rec, &in);\n+\t\ttest_copy(&rec);\n+\t\treftable_record_key(&rec, &key);\n+\t\tn = reftable_record_encode(&rec, dest, SHA1_SIZE);\n+\t\tassert(n > 0);\n+\t\textra = reftable_record_val_type(&rec);\n+\t\treftable_record_from_obj(&rec_out, &out);\n+\t\tm = reftable_record_decode(&rec_out, key, extra, dest,\n+\t\t\t\t\t SHA1_SIZE);\n+\t\tassert(n == m);\n+\n+\t\tassert(in.hash_prefix_len == out.hash_prefix_len);\n+\t\tassert(in.offset_len == out.offset_len);\n+\n+\t\tassert(!memcmp(in.hash_prefix, out.hash_prefix,\n+\t\t\t in.hash_prefix_len));\n+\t\tassert(0 == memcmp(in.offsets, out.offsets,\n+\t\t\t\t sizeof(uint64_t) * in.offset_len));\n+\t\tstrbuf_release(&key);\n+\t\treftable_record_clear(&rec_out);\n+\t}\n+}\n+\n+static void test_reftable_index_record_roundtrip(void)\n+{\n+\tstruct reftable_index_record in = {\n+\t\t.offset = 42,\n+\t\t.last_key = STRBUF_INIT,\n+\t};\n+\tuint8_t buffer = { 0 };\n+\tstruct string_view dest = {\n+\t\t.buf = buffer,\n+\t\t.len = sizeof(buffer),\n+\t};\n+\tstruct strbuf key = STRBUF_INIT;\n+\tstruct reftable_record rec = { NULL };\n+\tstruct reftable_index_record out = { .last_key = STRBUF_INIT };\n+\tstruct reftable_record out_rec = { NULL };\n+\tint n, m;\n+\tuint8_t extra;\n+\n+\treftable_record_from_index(&rec, &in);\n+\treftable_record_key(&rec, &key);\n+\ttest_copy(&rec);\n+\n+\tassert(0 == strbuf_cmp(&key, &in.last_key));\n+\tn = reftable_record_encode(&rec, dest, SHA1_SIZE);\n+\tassert(n > 0);\n+\n+\textra = reftable_record_val_type(&rec);\n+\treftable_record_from_index(&out_rec, &out);\n+\tm = reftable_record_decode(&out_rec, key, extra, dest, SHA1_SIZE);\n+\tassert(m == n);\n+\n+\tassert(in.offset == out.offset);\n+\n+\treftable_record_clear(&out_rec);\n+\tstrbuf_release(&key);\n+\tstrbuf_release(&in.last_key);\n+}\n+\n+int record_test_main(int argc, const char *argv[])\n+{\n+\t\t &test_reftable_log_record_equal);\n+\t\t &test_reftable_log_record_roundtrip);\n+\t\t &test_reftable_ref_record_roundtrip);\n+\t\t &test_reftable_obj_record_roundtrip);\n+\t\t &test_reftable_index_record_roundtrip);\n+\treturn test_main(argc, argv);\n+}\ndiff --git a/t/helper/test-reftable.c b/t/helper/test-reftable.c\nindex 7d50aa6bcc..9341272089 100644\n--- a/t/helper/test-reftable.c\n+++ b/t/helper/test-reftable.c\n@@ -3,6 +3,7 @@\n\nint cmd__reftable(int argc, const char **argv)\n{\n+\trecord_test_main(argc, argv);\nstrbuf_test_main(argc, argv);\nreturn 0;\n}\n--\n\n• ```* Re: [PATCH v2 06/13] reftable: (de)serialization for the polymorphic record type.\n2020-10-01 16:10 ` [PATCH v2 06/13] reftable: (de)serialization for the polymorphic record type Han-Wen Nienhuys via GitGitGadget\n@ 2020-10-01 19:23 ` Junio C Hamano\n2020-10-01 19:59 ` Ramsay Jones\nFrom: Junio C Hamano @ 2020-10-01 19:23 UTC (permalink / raw)\nTo: Han-Wen Nienhuys via GitGitGadget, Ramsay Jones\nCc: git, Han-Wen Nienhuys, Jeff King, Han-Wen Nienhuys\n\n> +struct reftable_record reftable_new_record(uint8_t typ)\n> +{\n> +\tstruct reftable_record rec = { NULL };\n\nI can see a lot of \"sparse\" inspired work went into this, but we\nwould want to take the previous discussion into account, as nothing\nhas changed since then.\n\nhttps://lore.kernel.org/git/[email protected]/\n\nhttps://lore.kernel.org/git/[email protected]/\n\nUnfortunately we didn't reach a clear consensus back then; I thought\nwe saw a fix to make sparse silent when we use the \"= { 0 }\" idiom\nmention of it, so either I am misremembering or there were other\ndiscussions on the same topic where it was also mentioned.\n\n> +\tswitch (typ) {\n\nNeed blank before this line.\n\nThanks.\n\n• ```* Re: [PATCH v2 06/13] reftable: (de)serialization for the polymorphic record type.\n2020-10-01 19:23 ` Junio C Hamano\n@ 2020-10-01 19:59 ` Ramsay Jones\n0 siblings, 0 replies; 251+ messages in thread\nFrom: Ramsay Jones @ 2020-10-01 19:59 UTC (permalink / raw)\nTo: Junio C Hamano, Han-Wen Nienhuys via GitGitGadget\nCc: git, Han-Wen Nienhuys, Jeff King, Han-Wen Nienhuys\n\nOn 01/10/2020 20:23, Junio C Hamano wrote:\n>\n>> +struct reftable_record reftable_new_record(uint8_t typ)\n>> +{\n>> +\tstruct reftable_record rec = { NULL };\n>\n> I can see a lot of \"sparse\" inspired work went into this, but we\n> would want to take the previous discussion into account, as nothing\n> has changed since then.\n>\n> https://lore.kernel.org/git/[email protected]/\n>\n> https://lore.kernel.org/git/[email protected]/\n\nyep, sparse is equally happy with = { 0 }; here - at least any sparse\nversion after 'v0.6.1-246-g41f651b4'. ;-) So, as I said yesterday, the\nlast official release v0.6.2 should be fine, and I _think_ Debian Testing\nhas a suitable version. (or you could build from source).\n\n> Unfortunately we didn't reach a clear consensus back then; I thought\n> we saw a fix to make sparse silent when we use the \"= { 0 }\" idiom\n> mention of it, so either I am misremembering or there were other\n> discussions on the same topic where it was also mentioned.\n\nSee commit 1c96642326 (sparse: allow '{ 0 }' to be used without warnings,\n22-05-2020). We could actually remove that now, since '-Wno-universal-initializer'\nis now the default (but it doesn't hurt).\n\nATB,\nRamsay Jones\n\n• ```* [PATCH v2 07/13] reftable: reading/writing blocks\n2020-10-01 16:10 ` [PATCH v2 00/13] reftable library Han-Wen Nienhuys via GitGitGadget\n` (5 preceding siblings ...)\n2020-10-01 16:10 ` [PATCH v2 06/13] reftable: (de)serialization for the polymorphic record type Han-Wen Nienhuys via GitGitGadget\n@ 2020-10-01 16:10 ` Han-Wen Nienhuys via GitGitGadget\n2020-10-01 16:10 ` [PATCH v2 08/13] reftable: a generic binary tree implementation Han-Wen Nienhuys via GitGitGadget\n` (6 subsequent siblings)\n13 siblings, 0 replies; 251+ messages in thread\nFrom: Han-Wen Nienhuys via GitGitGadget @ 2020-10-01 16:10 UTC (permalink / raw)\nTo: git; +Cc: Han-Wen Nienhuys, Jeff King, Han-Wen Nienhuys, Han-Wen Nienhuys\n\nIncludes a code snippet copied from zlib\n\n---\nMakefile | 3 +\nreftable/.gitattributes | 1 +\nreftable/block.c | 441 +++++++++++++++++++++++++++++++++++++++\nreftable/block.h | 129 ++++++++++++\nreftable/block_test.c | 158 ++++++++++++++\nreftable/zlib-compat.c | 92 ++++++++\nt/helper/test-reftable.c | 1 +\n7 files changed, 825 insertions(+)\ncreate mode 100644 reftable/.gitattributes\ncreate mode 100644 reftable/block.c\ncreate mode 100644 reftable/block.h\ncreate mode 100644 reftable/block_test.c\ncreate mode 100644 reftable/zlib-compat.c\n\ndiff --git a/Makefile b/Makefile\nindex b5e43d79ed..eda92b00ef 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -2373,12 +2373,15 @@ XDIFF_OBJS += xdiff/xprepare.o\nXDIFF_OBJS += xdiff/xutils.o\n\nREFTABLE_OBJS += reftable/basics.o\n+REFTABLE_OBJS += reftable/block.o\nREFTABLE_OBJS += reftable/blocksource.o\nREFTABLE_OBJS += reftable/publicbasics.o\nREFTABLE_OBJS += reftable/compat.o\nREFTABLE_OBJS += reftable/record.o\nREFTABLE_OBJS += reftable/strbuf.o\n+REFTABLE_OBJS += reftable/zlib-compat.o\n\n+REFTABLE_TEST_OBJS += reftable/block_test.o\nREFTABLE_TEST_OBJS += reftable/record_test.o\nREFTABLE_TEST_OBJS += reftable/strbuf_test.o\nREFTABLE_TEST_OBJS += reftable/test_framework.o\ndiff --git a/reftable/.gitattributes b/reftable/.gitattributes\nnew file mode 100644\nindex 0000000000..f44451a379\n--- /dev/null\n+++ b/reftable/.gitattributes\n@@ -0,0 +1 @@\n+/zlib-compat.c\twhitespace=-indent-with-non-tab,-trailing-space\ndiff --git a/reftable/block.c b/reftable/block.c\nnew file mode 100644\nindex 0000000000..d49e80df7c\n--- /dev/null\n+++ b/reftable/block.c\n@@ -0,0 +1,441 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"block.h\"\n+\n+#include \"blocksource.h\"\n+#include \"constants.h\"\n+#include \"record.h\"\n+#include \"reftable.h\"\n+#include \"system.h\"\n+#include \"zlib.h\"\n+\n+{\n+\tswitch (version) {\n+\tcase 1:\n+\t\treturn 24;\n+\tcase 2:\n+\t\treturn 28;\n+\t}\n+\tabort();\n+}\n+\n+int footer_size(int version)\n+{\n+\tswitch (version) {\n+\tcase 1:\n+\t\treturn 68;\n+\tcase 2:\n+\t\treturn 72;\n+\t}\n+\tabort();\n+}\n+\n+static int block_writer_register_restart(struct block_writer *w, int n,\n+\t\t\t\t\t int is_restart, struct strbuf *key)\n+{\n+\tint rlen = w->restart_len;\n+\tif (rlen >= MAX_RESTARTS) {\n+\t\tis_restart = 0;\n+\t}\n+\n+\tif (is_restart) {\n+\t\trlen++;\n+\t}\n+\tif (2 + 3 * rlen + n > w->block_size - w->next)\n+\t\treturn -1;\n+\tif (is_restart) {\n+\t\tif (w->restart_len == w->restart_cap) {\n+\t\t\tw->restart_cap = w->restart_cap * 2 + 1;\n+\t\t\tw->restarts = reftable_realloc(\n+\t\t\t\tw->restarts, sizeof(uint32_t) * w->restart_cap);\n+\t\t}\n+\n+\t\tw->restarts[w->restart_len++] = w->next;\n+\t}\n+\n+\tw->next += n;\n+\n+\tstrbuf_reset(&w->last_key);\n+\tw->entries++;\n+\treturn 0;\n+}\n+\n+void block_writer_init(struct block_writer *bw, uint8_t typ, uint8_t *buf,\n+\t\t uint32_t block_size, uint32_t header_off, int hash_size)\n+{\n+\tbw->buf = buf;\n+\tbw->hash_size = hash_size;\n+\tbw->block_size = block_size;\n+\tbw->next = header_off + 4;\n+\tbw->restart_interval = 16;\n+\tbw->entries = 0;\n+\tbw->restart_len = 0;\n+\tbw->last_key.len = 0;\n+}\n+\n+uint8_t block_writer_type(struct block_writer *bw)\n+{\n+}\n+\n+/* adds the reftable_record to the block. Returns -1 if it does not fit, 0 on\n+ success */\n+int block_writer_add(struct block_writer *w, struct reftable_record *rec)\n+{\n+\tstruct strbuf empty = STRBUF_INIT;\n+\tstruct strbuf last =\n+\t\tw->entries % w->restart_interval == 0 ? empty : w->last_key;\n+\tstruct string_view out = {\n+\t\t.buf = w->buf + w->next,\n+\t\t.len = w->block_size - w->next,\n+\t};\n+\n+\tstruct string_view start = out;\n+\n+\tint is_restart = 0;\n+\tstruct strbuf key = STRBUF_INIT;\n+\tint n = 0;\n+\n+\treftable_record_key(rec, &key);\n+\tn = reftable_encode_key(&is_restart, out, last, key,\n+\t\t\t\treftable_record_val_type(rec));\n+\tif (n < 0)\n+\t\tgoto done;\n+\tstring_view_consume(&out, n);\n+\n+\tn = reftable_record_encode(rec, out, w->hash_size);\n+\tif (n < 0)\n+\t\tgoto done;\n+\tstring_view_consume(&out, n);\n+\n+\tif (block_writer_register_restart(w, start.len - out.len, is_restart,\n+\t\t\t\t\t &key) < 0)\n+\t\tgoto done;\n+\n+\tstrbuf_release(&key);\n+\treturn 0;\n+\n+done:\n+\tstrbuf_release(&key);\n+\treturn -1;\n+}\n+\n+\n+int block_writer_finish(struct block_writer *w)\n+{\n+\tint i = 0;\n+\tfor (i = 0; i < w->restart_len; i++) {\n+\t\tput_be24(w->buf + w->next, w->restarts[i]);\n+\t\tw->next += 3;\n+\t}\n+\n+\tput_be16(w->buf + w->next, w->restart_len);\n+\tw->next += 2;\n+\tput_be24(w->buf + 1 + w->header_off, w->next);\n+\n+\tif (block_writer_type(w) == BLOCK_TYPE_LOG) {\n+\t\tuint8_t *compressed = NULL;\n+\t\tint zresult = 0;\n+\t\tuLongf src_len = w->next - block_header_skip;\n+\t\tsize_t dest_cap = src_len;\n+\n+\t\tcompressed = reftable_malloc(dest_cap);\n+\t\twhile (1) {\n+\t\t\tuLongf out_dest_len = dest_cap;\n+\n+\t\t\tzresult = compress2(compressed, &out_dest_len,\n+\t\t\t\t\t 9);\n+\t\t\tif (zresult == Z_BUF_ERROR) {\n+\t\t\t\tdest_cap *= 2;\n+\t\t\t\tcompressed =\n+\t\t\t\t\treftable_realloc(compressed, dest_cap);\n+\t\t\t\tcontinue;\n+\t\t\t}\n+\n+\t\t\tif (Z_OK != zresult) {\n+\t\t\t\treftable_free(compressed);\n+\t\t\t\treturn REFTABLE_ZLIB_ERROR;\n+\t\t\t}\n+\n+\t\t\t out_dest_len);\n+\t\t\tw->next = out_dest_len + block_header_skip;\n+\t\t\treftable_free(compressed);\n+\t\t\tbreak;\n+\t\t}\n+\t}\n+\treturn w->next;\n+}\n+\n+{\n+}\n+\n+\t\t int hash_size)\n+{\n+\tuint32_t full_block_size = table_block_size;\n+\tuint32_t sz = get_be24(block->data + header_off + 1);\n+\n+\tuint16_t restart_count = 0;\n+\tuint32_t restart_start = 0;\n+\tuint8_t *restart_bytes = NULL;\n+\n+\tif (!reftable_is_block_type(typ))\n+\t\treturn REFTABLE_FORMAT_ERROR;\n+\n+\tif (typ == BLOCK_TYPE_LOG) {\n+\t\tuLongf dst_len = sz - block_header_skip; /* total size of dest\n+\t\t\t\t\t\t\t buffer. */\n+\t\tuLongf src_len = block->len - block_header_skip;\n+\t\t/* Log blocks specify the *uncompressed* size in their header.\n+\t\t */\n+\t\tuint8_t *uncompressed = reftable_malloc(sz);\n+\n+\t\t/* Copy over the block header verbatim. It's not compressed. */\n+\n+\t\t/* Uncompress */\n+\t\tif (Z_OK != uncompress_return_consumed(\n+\t\t\t\t &src_len)) {\n+\t\t\treftable_free(uncompressed);\n+\t\t\treturn REFTABLE_ZLIB_ERROR;\n+\t\t}\n+\n+\t\tif (dst_len + block_header_skip != sz)\n+\t\t\treturn REFTABLE_FORMAT_ERROR;\n+\n+\t\t/* We're done with the input data. */\n+\t\treftable_block_done(block);\n+\t\tblock->data = uncompressed;\n+\t\tblock->len = sz;\n+\t\tblock->source = malloc_block_source();\n+\t\tfull_block_size = src_len + block_header_skip;\n+\t} else if (full_block_size == 0) {\n+\t\tfull_block_size = sz;\n+\t} else if (sz < full_block_size && sz < block->len &&\n+\t\t block->data[sz] != 0) {\n+\t\t/* If the block is smaller than the full block size, it is\n+\t\t padded (data followed by '\\0') or the next block is\n+\t\t unaligned. */\n+\t\tfull_block_size = sz;\n+\t}\n+\n+\trestart_count = get_be16(block->data + sz - 2);\n+\trestart_start = sz - 2 - 3 * restart_count;\n+\trestart_bytes = block->data + restart_start;\n+\n+\t/* transfer ownership. */\n+\tbr->block = *block;\n+\tblock->data = NULL;\n+\tblock->len = 0;\n+\n+\tbr->hash_size = hash_size;\n+\tbr->block_len = restart_start;\n+\tbr->full_block_size = full_block_size;\n+\tbr->restart_count = restart_count;\n+\tbr->restart_bytes = restart_bytes;\n+\n+\treturn 0;\n+}\n+\n+{\n+\treturn get_be24(br->restart_bytes + 3 * i);\n+}\n+\n+{\n+\tit->br = br;\n+\tstrbuf_reset(&it->last_key);\n+\tit->next_off = br->header_off + 4;\n+}\n+\n+struct restart_find_args {\n+\tint error;\n+\tstruct strbuf key;\n+};\n+\n+static int restart_key_less(size_t idx, void *args)\n+{\n+\tstruct restart_find_args *a = (struct restart_find_args *)args;\n+\tuint32_t off = block_reader_restart_offset(a->r, idx);\n+\tstruct string_view in = {\n+\t\t.buf = a->r->block.data + off,\n+\t\t.len = a->r->block_len - off,\n+\t};\n+\n+\t/* the restart key is verbatim in the block, so this could avoid the\n+\t alloc for decoding the key */\n+\tstruct strbuf rkey = STRBUF_INIT;\n+\tstruct strbuf last_key = STRBUF_INIT;\n+\tuint8_t unused_extra;\n+\tint n = reftable_decode_key(&rkey, &unused_extra, last_key, in);\n+\tint result;\n+\tif (n < 0) {\n+\t\ta->error = 1;\n+\t\treturn -1;\n+\t}\n+\n+\tresult = strbuf_cmp(&a->key, &rkey);\n+\tstrbuf_release(&rkey);\n+\treturn result;\n+}\n+\n+void block_iter_copy_from(struct block_iter *dest, struct block_iter *src)\n+{\n+\tdest->br = src->br;\n+\tdest->next_off = src->next_off;\n+\tstrbuf_reset(&dest->last_key);\n+}\n+\n+int block_iter_next(struct block_iter *it, struct reftable_record *rec)\n+{\n+\tstruct string_view in = {\n+\t\t.buf = it->br->block.data + it->next_off,\n+\t\t.len = it->br->block_len - it->next_off,\n+\t};\n+\tstruct string_view start = in;\n+\tstruct strbuf key = STRBUF_INIT;\n+\tuint8_t extra = 0;\n+\tint n = 0;\n+\n+\tif (it->next_off >= it->br->block_len)\n+\t\treturn 1;\n+\n+\tn = reftable_decode_key(&key, &extra, it->last_key, in);\n+\tif (n < 0)\n+\t\treturn -1;\n+\n+\tstring_view_consume(&in, n);\n+\tn = reftable_record_decode(rec, key, extra, in, it->br->hash_size);\n+\tif (n < 0)\n+\t\treturn -1;\n+\tstring_view_consume(&in, n);\n+\n+\tstrbuf_reset(&it->last_key);\n+\tit->next_off += start.len - in.len;\n+\tstrbuf_release(&key);\n+\treturn 0;\n+}\n+\n+{\n+\tstruct strbuf empty = STRBUF_INIT;\n+\tint off = br->header_off + 4;\n+\tstruct string_view in = {\n+\t\t.buf = br->block.data + off,\n+\t\t.len = br->block_len - off,\n+\t};\n+\n+\tuint8_t extra = 0;\n+\tint n = reftable_decode_key(key, &extra, empty, in);\n+\tif (n < 0)\n+\t\treturn n;\n+\n+\treturn 0;\n+}\n+\n+int block_iter_seek(struct block_iter *it, struct strbuf *want)\n+{\n+}\n+\n+void block_iter_close(struct block_iter *it)\n+{\n+\tstrbuf_release(&it->last_key);\n+}\n+\n+\t\t struct strbuf *want)\n+{\n+\tstruct restart_find_args args = {\n+\t\t.key = *want,\n+\t\t.r = br,\n+\t};\n+\tstruct reftable_record rec = reftable_new_record(block_reader_type(br));\n+\tstruct strbuf key = STRBUF_INIT;\n+\tint err = 0;\n+\tstruct block_iter next = {\n+\t\t.last_key = STRBUF_INIT,\n+\t};\n+\n+\tint i = binsearch(br->restart_count, &restart_key_less, &args);\n+\tif (args.error) {\n+\t\terr = REFTABLE_FORMAT_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+\tit->br = br;\n+\tif (i > 0) {\n+\t\ti--;\n+\t} else {\n+\t\tit->next_off = br->header_off + 4;\n+\t}\n+\n+\t/* We're looking for the last entry less/equal than the wanted key, so\n+\t we have to go one entry too far and then back up.\n+\t*/\n+\twhile (1) {\n+\t\tblock_iter_copy_from(&next, it);\n+\t\terr = block_iter_next(&next, &rec);\n+\t\tif (err < 0)\n+\t\t\tgoto done;\n+\n+\t\treftable_record_key(&rec, &key);\n+\t\tif (err > 0 || strbuf_cmp(&key, want) >= 0) {\n+\t\t\terr = 0;\n+\t\t\tgoto done;\n+\t\t}\n+\n+\t\tblock_iter_copy_from(it, &next);\n+\t}\n+\n+done:\n+\tstrbuf_release(&key);\n+\tstrbuf_release(&next.last_key);\n+\treftable_record_destroy(&rec);\n+\n+\treturn err;\n+}\n+\n+void block_writer_clear(struct block_writer *bw)\n+{\n+\tFREE_AND_NULL(bw->restarts);\n+\tstrbuf_release(&bw->last_key);\n+\t/* the block is not owned. */\n+}\n+\n+void reftable_block_done(struct reftable_block *blockp)\n+{\n+\tstruct reftable_block_source source = blockp->source;\n+\tif (blockp != NULL && source.ops != NULL)\n+\t\tsource.ops->return_block(source.arg, blockp);\n+\tblockp->data = NULL;\n+\tblockp->len = 0;\n+\tblockp->source.ops = NULL;\n+\tblockp->source.arg = NULL;\n+}\ndiff --git a/reftable/block.h b/reftable/block.h\nnew file mode 100644\nindex 0000000000..14a6f835f4\n--- /dev/null\n+++ b/reftable/block.h\n@@ -0,0 +1,129 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#ifndef BLOCK_H\n+#define BLOCK_H\n+\n+#include \"basics.h\"\n+#include \"record.h\"\n+#include \"reftable.h\"\n+\n+/*\n+ Writes reftable blocks. The block_writer is reused across blocks to minimize\n+*/\n+struct block_writer {\n+\tuint8_t *buf;\n+\tuint32_t block_size;\n+\n+\t/* Offset ofof the global header. Nonzero in the first block only. */\n+\n+\t/* How often to restart keys. */\n+\tint restart_interval;\n+\tint hash_size;\n+\n+\t/* Offset of next uint8_t to write. */\n+\tuint32_t next;\n+\tuint32_t *restarts;\n+\tuint32_t restart_len;\n+\tuint32_t restart_cap;\n+\n+\tstruct strbuf last_key;\n+\tint entries;\n+};\n+\n+/*\n+ initializes the blockwriter to write `typ` entries, using `buf` as temporary\n+ storage. `buf` is not owned by the block_writer. */\n+void block_writer_init(struct block_writer *bw, uint8_t typ, uint8_t *buf,\n+\t\t uint32_t block_size, uint32_t header_off, int hash_size);\n+\n+/*\n+ returns the block type (eg. 'r' for ref records.\n+*/\n+uint8_t block_writer_type(struct block_writer *bw);\n+\n+/* appends the record, or -1 if it doesn't fit. */\n+int block_writer_add(struct block_writer *w, struct reftable_record *rec);\n+\n+/* appends the key restarts, and compress the block if necessary. */\n+int block_writer_finish(struct block_writer *w);\n+\n+/* clears out internally allocated block_writer members. */\n+void block_writer_clear(struct block_writer *bw);\n+\n+\t/* offset of the block header; nonzero for the first block in a\n+\t * reftable. */\n+\n+\t/* the memory block */\n+\tstruct reftable_block block;\n+\tint hash_size;\n+\n+\t/* size of the data, excluding restart data. */\n+\tuint32_t block_len;\n+\tuint8_t *restart_bytes;\n+\tuint16_t restart_count;\n+\n+\t/* size of the data in the file. For log blocks, this is the compressed\n+\t * size. */\n+\tuint32_t full_block_size;\n+};\n+\n+/* Iterate over entries in a block */\n+struct block_iter {\n+\t/* offset within the block of the next entry to read. */\n+\tuint32_t next_off;\n+\n+\t/* key for last entry we read. */\n+\tstruct strbuf last_key;\n+};\n+\n+/* initializes a block reader. */\n+\t\t int hash_size);\n+\n+/* Position `it` at start of the block */\n+\n+/* Position `it` to the `want` key in the block */\n+\t\t struct strbuf *want);\n+\n+/* Returns the block type (eg. 'r' for refs) */\n+\n+/* Decodes the first key in the block */\n+\n+void block_iter_copy_from(struct block_iter *dest, struct block_iter *src);\n+\n+/* return < 0 for error, 0 for OK, > 0 for EOF. */\n+int block_iter_next(struct block_iter *it, struct reftable_record *rec);\n+\n+/* Seek to `want` with in the block pointed to by `it` */\n+int block_iter_seek(struct block_iter *it, struct strbuf *want);\n+\n+/* deallocate memory for `it`. The block reader and its block is left intact. */\n+void block_iter_close(struct block_iter *it);\n+\n+/* size of file header, depending on format version */\n+\n+/* size of file footer, depending on format version */\n+int footer_size(int version);\n+\n+/* returns a block to its source. */\n+void reftable_block_done(struct reftable_block *ret);\n+\n+#endif\ndiff --git a/reftable/block_test.c b/reftable/block_test.c\nnew file mode 100644\nindex 0000000000..2fa8ca9831\n--- /dev/null\n+++ b/reftable/block_test.c\n@@ -0,0 +1,158 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"block.h\"\n+\n+#include \"system.h\"\n+\n+#include \"blocksource.h\"\n+#include \"basics.h\"\n+#include \"constants.h\"\n+#include \"record.h\"\n+#include \"reftable.h\"\n+#include \"test_framework.h\"\n+#include \"reftable-tests.h\"\n+\n+struct binsearch_args {\n+\tint key;\n+\tint *arr;\n+};\n+\n+static int binsearch_func(size_t i, void *void_args)\n+{\n+\tstruct binsearch_args *args = (struct binsearch_args *)void_args;\n+\n+\treturn args->key < args->arr[i];\n+}\n+\n+static void test_binsearch(void)\n+{\n+\tint arr[] = { 2, 4, 6, 8, 10 };\n+\tsize_t sz = ARRAY_SIZE(arr);\n+\tstruct binsearch_args args = {\n+\t\t.arr = arr,\n+\t};\n+\n+\tint i = 0;\n+\tfor (i = 1; i < 11; i++) {\n+\t\tint res;\n+\t\targs.key = i;\n+\t\tres = binsearch(sz, &binsearch_func, &args);\n+\n+\t\tif (res < sz) {\n+\t\t\tassert(args.key < arr[res]);\n+\t\t\tif (res > 0) {\n+\t\t\t\tassert(args.key >= arr[res - 1]);\n+\t\t\t}\n+\t\t} else {\n+\t\t\tassert(args.key == 10 || args.key == 11);\n+\t\t}\n+\t}\n+}\n+\n+{\n+\tconst int header_off = 21; /* random */\n+\tchar *names;\n+\tconst int N = ARRAY_SIZE(names);\n+\tconst int block_size = 1024;\n+\tstruct reftable_block block = { NULL };\n+\tstruct block_writer bw = {\n+\t\t.last_key = STRBUF_INIT,\n+\t};\n+\tstruct reftable_ref_record ref = { NULL };\n+\tstruct reftable_record rec = { NULL };\n+\tint i = 0;\n+\tint n;\n+\tstruct block_reader br = { 0 };\n+\tstruct block_iter it = { .last_key = STRBUF_INIT };\n+\tint j = 0;\n+\tstruct strbuf want = STRBUF_INIT;\n+\n+\tblock.data = reftable_calloc(block_size);\n+\tblock.len = block_size;\n+\tblock.source = malloc_block_source();\n+\tblock_writer_init(&bw, BLOCK_TYPE_REF, block.data, block_size,\n+\treftable_record_from_ref(&rec, &ref);\n+\n+\tfor (i = 0; i < N; i++) {\n+\t\tchar name;\n+\t\tuint8_t hash[SHA1_SIZE];\n+\t\tsnprintf(name, sizeof(name), \"branch%02d\", i);\n+\t\tmemset(hash, i, sizeof(hash));\n+\n+\t\tref.refname = name;\n+\t\tref.value = hash;\n+\t\tnames[i] = xstrdup(name);\n+\t\tref.refname = NULL;\n+\t\tref.value = NULL;\n+\t\tassert(n == 0);\n+\t}\n+\n+\tn = block_writer_finish(&bw);\n+\tassert(n > 0);\n+\n+\tblock_writer_clear(&bw);\n+\n+\n+\n+\twhile (1) {\n+\t\tint r = block_iter_next(&it, &rec);\n+\t\tassert(r >= 0);\n+\t\tif (r > 0) {\n+\t\t\tbreak;\n+\t\t}\n+\t\tassert_streq(names[j], ref.refname);\n+\t\tj++;\n+\t}\n+\n+\treftable_record_clear(&rec);\n+\tblock_iter_close(&it);\n+\n+\tfor (i = 0; i < N; i++) {\n+\t\tstruct block_iter it = { .last_key = STRBUF_INIT };\n+\t\tstrbuf_reset(&want);\n+\n+\t\tn = block_reader_seek(&br, &it, &want);\n+\t\tassert(n == 0);\n+\n+\t\tn = block_iter_next(&it, &rec);\n+\t\tassert(n == 0);\n+\n+\t\tassert_streq(names[i], ref.refname);\n+\n+\t\twant.len--;\n+\t\tn = block_reader_seek(&br, &it, &want);\n+\t\tassert(n == 0);\n+\n+\t\tn = block_iter_next(&it, &rec);\n+\t\tassert(n == 0);\n+\t\tassert_streq(names[10 * (i / 10)], ref.refname);\n+\n+\t\tblock_iter_close(&it);\n+\t}\n+\n+\treftable_record_clear(&rec);\n+\treftable_block_done(&br.block);\n+\tstrbuf_release(&want);\n+\tfor (i = 0; i < N; i++) {\n+\t\treftable_free(names[i]);\n+\t}\n+}\n+\n+int block_test_main(int argc, const char *argv[])\n+{\n+\treturn test_main(argc, argv);\n+}\ndiff --git a/reftable/zlib-compat.c b/reftable/zlib-compat.c\nnew file mode 100644\nindex 0000000000..3e0b0f24f1\n--- /dev/null\n+++ b/reftable/zlib-compat.c\n@@ -0,0 +1,92 @@\n+/* taken from zlib's uncompr.c\n+\n+ commit cacf7f1d4e3d44d871b605da3b647f07d718623f\n+ Date: Sun Jan 15 09:18:46 2017 -0800\n+\n+ zlib 1.2.11\n+\n+*/\n+\n+/*\n+ * Copyright (C) 1995-2003, 2010, 2014, 2016 Jean-loup Gailly, Mark Adler\n+ * For conditions of distribution and use, see copyright notice in zlib.h\n+ */\n+\n+#include \"system.h\"\n+\n+/* clang-format off */\n+\n+/* ===========================================================================\n+ Decompresses the source buffer into the destination buffer. *sourceLen is\n+ the byte length of the source buffer. Upon entry, *destLen is the total size\n+ of the destination buffer, which must be large enough to hold the entire\n+ uncompressed data. (The size of the uncompressed data must have been saved\n+ previously by the compressor and transmitted to the decompressor by some\n+ mechanism outside the scope of this compression library.) Upon exit,\n+ *destLen is the size of the decompressed data and *sourceLen is the number\n+ of source bytes consumed. Upon return, source + *sourceLen points to the\n+ first unused input byte.\n+\n+ uncompress returns Z_OK if success, Z_MEM_ERROR if there was not enough\n+ memory, Z_BUF_ERROR if there was not enough room in the output buffer, or\n+ Z_DATA_ERROR if the input data was corrupted, including if the input data is\n+ an incomplete zlib stream.\n+*/\n+int ZEXPORT uncompress_return_consumed (\n+ Bytef *dest,\n+ uLongf *destLen,\n+ const Bytef *source,\n+ uLong *sourceLen) {\n+ z_stream stream;\n+ int err;\n+ const uInt max = (uInt)-1;\n+ uLong len, left;\n+ Byte buf; /* for detection of incomplete stream when *destLen == 0 */\n+\n+ len = *sourceLen;\n+ if (*destLen) {\n+ left = *destLen;\n+ *destLen = 0;\n+ }\n+ else {\n+ left = 1;\n+ dest = buf;\n+ }\n+\n+ stream.next_in = (z_const Bytef *)source;\n+ stream.avail_in = 0;\n+ stream.zalloc = (alloc_func)0;\n+ stream.zfree = (free_func)0;\n+ stream.opaque = (voidpf)0;\n+\n+ err = inflateInit(&stream);\n+ if (err != Z_OK) return err;\n+\n+ stream.next_out = dest;\n+ stream.avail_out = 0;\n+\n+ do {\n+ if (stream.avail_out == 0) {\n+ stream.avail_out = left > (uLong)max ? max : (uInt)left;\n+ left -= stream.avail_out;\n+ }\n+ if (stream.avail_in == 0) {\n+ stream.avail_in = len > (uLong)max ? max : (uInt)len;\n+ len -= stream.avail_in;\n+ }\n+ err = inflate(&stream, Z_NO_FLUSH);\n+ } while (err == Z_OK);\n+\n+ *sourceLen -= len + stream.avail_in;\n+ if (dest != buf)\n+ *destLen = stream.total_out;\n+ else if (stream.total_out && err == Z_BUF_ERROR)\n+ left = 1;\n+\n+ inflateEnd(&stream);\n+ return err == Z_STREAM_END ? Z_OK :\n+ err == Z_NEED_DICT ? Z_DATA_ERROR :\n+ err == Z_BUF_ERROR && left + stream.avail_out ? Z_DATA_ERROR :\n+ err;\n+}\ndiff --git a/t/helper/test-reftable.c b/t/helper/test-reftable.c\nindex 9341272089..81a9bd5667 100644\n--- a/t/helper/test-reftable.c\n+++ b/t/helper/test-reftable.c\n@@ -3,6 +3,7 @@\n\nint cmd__reftable(int argc, const char **argv)\n{\n+\tblock_test_main(argc, argv);\nrecord_test_main(argc, argv);\nstrbuf_test_main(argc, argv);\nreturn 0;\n--\n\n• ```* [PATCH v2 08/13] reftable: a generic binary tree implementation\n2020-10-01 16:10 ` [PATCH v2 00/13] reftable library Han-Wen Nienhuys via GitGitGadget\n` (6 preceding siblings ...)\n2020-10-01 16:10 ` [PATCH v2 07/13] reftable: reading/writing blocks Han-Wen Nienhuys via GitGitGadget\n@ 2020-10-01 16:10 ` Han-Wen Nienhuys via GitGitGadget\n2020-10-01 16:10 ` [PATCH v2 09/13] reftable: write reftable files Han-Wen Nienhuys via GitGitGadget\n` (5 subsequent siblings)\n13 siblings, 0 replies; 251+ messages in thread\nFrom: Han-Wen Nienhuys via GitGitGadget @ 2020-10-01 16:10 UTC (permalink / raw)\nTo: git; +Cc: Han-Wen Nienhuys, Jeff King, Han-Wen Nienhuys, Han-Wen Nienhuys\n\nThis is necessary for building a OID => ref map on write\n\n---\nMakefile | 2 ++\nreftable/tree.c | 63 ++++++++++++++++++++++++++++++++++++++++\nreftable/tree.h | 34 ++++++++++++++++++++++\nreftable/tree_test.c | 62 +++++++++++++++++++++++++++++++++++++++\nt/helper/test-reftable.c | 1 +\n5 files changed, 162 insertions(+)\ncreate mode 100644 reftable/tree.c\ncreate mode 100644 reftable/tree.h\ncreate mode 100644 reftable/tree_test.c\n\ndiff --git a/Makefile b/Makefile\nindex eda92b00ef..870e540f22 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -2379,12 +2379,14 @@ REFTABLE_OBJS += reftable/publicbasics.o\nREFTABLE_OBJS += reftable/compat.o\nREFTABLE_OBJS += reftable/record.o\nREFTABLE_OBJS += reftable/strbuf.o\n+REFTABLE_OBJS += reftable/tree.o\nREFTABLE_OBJS += reftable/zlib-compat.o\n\nREFTABLE_TEST_OBJS += reftable/block_test.o\nREFTABLE_TEST_OBJS += reftable/record_test.o\nREFTABLE_TEST_OBJS += reftable/strbuf_test.o\nREFTABLE_TEST_OBJS += reftable/test_framework.o\n+REFTABLE_TEST_OBJS += reftable/tree_test.o\n\nTEST_OBJS := \\$(patsubst %\\$X,%.o,\\$(TEST_PROGRAMS)) \\$(patsubst %,t/helper/%,\\$(TEST_BUILTINS_OBJS))\nOBJECTS := \\$(LIB_OBJS) \\$(BUILTIN_OBJS) \\$(PROGRAM_OBJS) \\$(TEST_OBJS) \\\ndiff --git a/reftable/tree.c b/reftable/tree.c\nnew file mode 100644\nindex 0000000000..0061d14e30\n--- /dev/null\n+++ b/reftable/tree.c\n@@ -0,0 +1,63 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"tree.h\"\n+\n+#include \"basics.h\"\n+#include \"system.h\"\n+\n+struct tree_node *tree_search(void *key, struct tree_node **rootp,\n+\t\t\t int (*compare)(const void *, const void *),\n+\t\t\t int insert)\n+{\n+\tint res;\n+\tif (*rootp == NULL) {\n+\t\tif (!insert) {\n+\t\t\treturn NULL;\n+\t\t} else {\n+\t\t\tstruct tree_node *n =\n+\t\t\t\treftable_calloc(sizeof(struct tree_node));\n+\t\t\tn->key = key;\n+\t\t\t*rootp = n;\n+\t\t\treturn *rootp;\n+\t\t}\n+\t}\n+\n+\tres = compare(key, (*rootp)->key);\n+\tif (res < 0)\n+\t\treturn tree_search(key, &(*rootp)->left, compare, insert);\n+\telse if (res > 0)\n+\t\treturn tree_search(key, &(*rootp)->right, compare, insert);\n+\treturn *rootp;\n+}\n+\n+void infix_walk(struct tree_node *t, void (*action)(void *arg, void *key),\n+\t\tvoid *arg)\n+{\n+\tif (t->left != NULL) {\n+\t\tinfix_walk(t->left, action, arg);\n+\t}\n+\taction(arg, t->key);\n+\tif (t->right != NULL) {\n+\t\tinfix_walk(t->right, action, arg);\n+\t}\n+}\n+\n+void tree_free(struct tree_node *t)\n+{\n+\tif (t == NULL) {\n+\t\treturn;\n+\t}\n+\tif (t->left != NULL) {\n+\t\ttree_free(t->left);\n+\t}\n+\tif (t->right != NULL) {\n+\t\ttree_free(t->right);\n+\t}\n+\treftable_free(t);\n+}\ndiff --git a/reftable/tree.h b/reftable/tree.h\nnew file mode 100644\nindex 0000000000..954512e9a3\n--- /dev/null\n+++ b/reftable/tree.h\n@@ -0,0 +1,34 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#ifndef TREE_H\n+#define TREE_H\n+\n+/* tree_node is a generic binary search tree. */\n+struct tree_node {\n+\tvoid *key;\n+\tstruct tree_node *left, *right;\n+};\n+\n+/* looks for `key` in `rootp` using `compare` as comparison function. If insert\n+ is set, insert the key if it's not found. Else, return NULL.\n+*/\n+struct tree_node *tree_search(void *key, struct tree_node **rootp,\n+\t\t\t int (*compare)(const void *, const void *),\n+\t\t\t int insert);\n+\n+/* performs an infix walk of the tree. */\n+void infix_walk(struct tree_node *t, void (*action)(void *arg, void *key),\n+\t\tvoid *arg);\n+\n+/*\n+ deallocates the tree nodes recursively. Keys should be deallocated separately\n+ by walking over the tree. */\n+void tree_free(struct tree_node *t);\n+\n+#endif\ndiff --git a/reftable/tree_test.c b/reftable/tree_test.c\nnew file mode 100644\nindex 0000000000..320fd02a0f\n--- /dev/null\n+++ b/reftable/tree_test.c\n@@ -0,0 +1,62 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"tree.h\"\n+\n+#include \"basics.h\"\n+#include \"record.h\"\n+#include \"reftable.h\"\n+#include \"test_framework.h\"\n+#include \"reftable-tests.h\"\n+\n+static int test_compare(const void *a, const void *b)\n+{\n+\treturn (char *)a - (char *)b;\n+}\n+\n+struct curry {\n+\tvoid *last;\n+};\n+\n+static void check_increasing(void *arg, void *key)\n+{\n+\tstruct curry *c = (struct curry *)arg;\n+\tif (c->last != NULL) {\n+\t\tassert(test_compare(c->last, key) < 0);\n+\t}\n+\tc->last = key;\n+}\n+\n+static void test_tree(void)\n+{\n+\tstruct tree_node *root = NULL;\n+\n+\tvoid *values = { NULL };\n+\tstruct tree_node *nodes = { NULL };\n+\tint i = 1;\n+\tstruct curry c = { NULL };\n+\tdo {\n+\t\tnodes[i] = tree_search(values + i, &root, &test_compare, 1);\n+\t\ti = (i * 7) % 11;\n+\t} while (i != 1);\n+\n+\tfor (i = 1; i < ARRAY_SIZE(nodes); i++) {\n+\t\tassert(values + i == nodes[i]->key);\n+\t\tassert(nodes[i] ==\n+\t\t tree_search(values + i, &root, &test_compare, 0));\n+\t}\n+\n+\tinfix_walk(root, check_increasing, &c);\n+\ttree_free(root);\n+}\n+\n+int tree_test_main(int argc, const char *argv[])\n+{\n+\treturn test_main(argc, argv);\n+}\ndiff --git a/t/helper/test-reftable.c b/t/helper/test-reftable.c\nindex 81a9bd5667..9c4e0f42dc 100644\n--- a/t/helper/test-reftable.c\n+++ b/t/helper/test-reftable.c\n@@ -6,5 +6,6 @@ int cmd__reftable(int argc, const char **argv)\nblock_test_main(argc, argv);\nrecord_test_main(argc, argv);\nstrbuf_test_main(argc, argv);\n+\ttree_test_main(argc, argv);\nreturn 0;\n}\n--\n\n• ```* [PATCH v2 09/13] reftable: write reftable files\n2020-10-01 16:10 ` [PATCH v2 00/13] reftable library Han-Wen Nienhuys via GitGitGadget\n` (7 preceding siblings ...)\n2020-10-01 16:10 ` [PATCH v2 08/13] reftable: a generic binary tree implementation Han-Wen Nienhuys via GitGitGadget\n@ 2020-10-01 16:10 ` Han-Wen Nienhuys via GitGitGadget\n2020-10-01 16:11 ` [PATCH v2 10/13] reftable: read \" Han-Wen Nienhuys via GitGitGadget\n` (4 subsequent siblings)\n13 siblings, 0 replies; 251+ messages in thread\nFrom: Han-Wen Nienhuys via GitGitGadget @ 2020-10-01 16:10 UTC (permalink / raw)\nTo: git; +Cc: Han-Wen Nienhuys, Jeff King, Han-Wen Nienhuys, Han-Wen Nienhuys\n\n---\nMakefile | 1 +\nreftable/writer.c | 673 ++++++++++++++++++++++++++++++++++++++++++++++\nreftable/writer.h | 51 ++++\n3 files changed, 725 insertions(+)\ncreate mode 100644 reftable/writer.c\ncreate mode 100644 reftable/writer.h\n\ndiff --git a/Makefile b/Makefile\nindex 870e540f22..c1dd046155 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -2380,6 +2380,7 @@ REFTABLE_OBJS += reftable/compat.o\nREFTABLE_OBJS += reftable/record.o\nREFTABLE_OBJS += reftable/strbuf.o\nREFTABLE_OBJS += reftable/tree.o\n+REFTABLE_OBJS += reftable/writer.o\nREFTABLE_OBJS += reftable/zlib-compat.o\n\nREFTABLE_TEST_OBJS += reftable/block_test.o\ndiff --git a/reftable/writer.c b/reftable/writer.c\nnew file mode 100644\n--- /dev/null\n+++ b/reftable/writer.c\n@@ -0,0 +1,673 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"writer.h\"\n+\n+#include \"system.h\"\n+\n+#include \"block.h\"\n+#include \"constants.h\"\n+#include \"record.h\"\n+#include \"reftable.h\"\n+#include \"tree.h\"\n+\n+/* finishes a block, and writes it to storage */\n+static int writer_flush_block(struct reftable_writer *w);\n+\n+/* deallocates memory related to the index */\n+static void writer_clear_index(struct reftable_writer *w);\n+\n+/* finishes writing a 'r' (refs) or 'g' (reflogs) section */\n+static int writer_finish_public_section(struct reftable_writer *w);\n+\n+static struct reftable_block_stats *\n+writer_reftable_block_stats(struct reftable_writer *w, uint8_t typ)\n+{\n+\tswitch (typ) {\n+\tcase 'r':\n+\t\treturn &w->stats.ref_stats;\n+\tcase 'o':\n+\t\treturn &w->stats.obj_stats;\n+\tcase 'i':\n+\t\treturn &w->stats.idx_stats;\n+\tcase 'g':\n+\t\treturn &w->stats.log_stats;\n+\t}\n+\tabort();\n+\treturn NULL;\n+}\n+\n+/* write data, queuing the padding for the next write. Returns negative for\n+ * error. */\n+static int padded_write(struct reftable_writer *w, uint8_t *data, size_t len,\n+{\n+\tint n = 0;\n+\tif (w->pending_padding > 0) {\n+\t\tint n = w->write(w->write_arg, zeroed, w->pending_padding);\n+\t\tif (n < 0)\n+\t\t\treturn n;\n+\n+\t\treftable_free(zeroed);\n+\t}\n+\n+\tn = w->write(w->write_arg, data, len);\n+\tif (n < 0)\n+\t\treturn n;\n+\treturn 0;\n+}\n+\n+static void options_set_defaults(struct reftable_write_options *opts)\n+{\n+\tif (opts->restart_interval == 0) {\n+\t\topts->restart_interval = 16;\n+\t}\n+\n+\tif (opts->hash_id == 0) {\n+\t\topts->hash_id = SHA1_ID;\n+\t}\n+\tif (opts->block_size == 0) {\n+\t\topts->block_size = DEFAULT_BLOCK_SIZE;\n+\t}\n+}\n+\n+static int writer_version(struct reftable_writer *w)\n+{\n+\treturn (w->opts.hash_id == 0 || w->opts.hash_id == SHA1_ID) ? 1 : 2;\n+}\n+\n+static int writer_write_header(struct reftable_writer *w, uint8_t *dest)\n+{\n+\tmemcpy((char *)dest, \"REFT\", 4);\n+\n+\tdest = writer_version(w);\n+\n+\tput_be24(dest + 5, w->opts.block_size);\n+\tput_be64(dest + 8, w->min_update_index);\n+\tput_be64(dest + 16, w->max_update_index);\n+\tif (writer_version(w) == 2) {\n+\t\tput_be32(dest + 24, w->opts.hash_id);\n+\t}\n+}\n+\n+static void writer_reinit_block_writer(struct reftable_writer *w, uint8_t typ)\n+{\n+\tint block_start = 0;\n+\tif (w->next == 0) {\n+\t}\n+\n+\tstrbuf_release(&w->last_key);\n+\tblock_writer_init(&w->block_writer_data, typ, w->block,\n+\t\t\t w->opts.block_size, block_start,\n+\t\t\t hash_size(w->opts.hash_id));\n+\tw->block_writer = &w->block_writer_data;\n+\tw->block_writer->restart_interval = w->opts.restart_interval;\n+}\n+\n+struct reftable_writer *\n+reftable_new_writer(int (*writer_func)(void *, const void *, size_t),\n+\t\t void *writer_arg, struct reftable_write_options *opts)\n+{\n+\tstruct reftable_writer *wp =\n+\t\treftable_calloc(sizeof(struct reftable_writer));\n+\tstrbuf_init(&wp->block_writer_data.last_key, 0);\n+\toptions_set_defaults(opts);\n+\tif (opts->block_size >= (1 << 24)) {\n+\t\t/* TODO - error return? */\n+\t\tabort();\n+\t}\n+\twp->last_key = reftable_empty_strbuf;\n+\twp->block = reftable_calloc(opts->block_size);\n+\twp->write = writer_func;\n+\twp->write_arg = writer_arg;\n+\twp->opts = *opts;\n+\twriter_reinit_block_writer(wp, BLOCK_TYPE_REF);\n+\n+\treturn wp;\n+}\n+\n+void reftable_writer_set_limits(struct reftable_writer *w, uint64_t min,\n+\t\t\t\tuint64_t max)\n+{\n+\tw->min_update_index = min;\n+\tw->max_update_index = max;\n+}\n+\n+void reftable_writer_free(struct reftable_writer *w)\n+{\n+\treftable_free(w->block);\n+\treftable_free(w);\n+}\n+\n+struct obj_index_tree_node {\n+\tstruct strbuf hash;\n+\tuint64_t *offsets;\n+\tsize_t offset_len;\n+\tsize_t offset_cap;\n+};\n+\n+#define OBJ_INDEX_TREE_NODE_INIT \\\n+\t{ \\\n+\t\t.hash = STRBUF_INIT \\\n+\t}\n+\n+static int obj_index_tree_node_compare(const void *a, const void *b)\n+{\n+\treturn strbuf_cmp(&((const struct obj_index_tree_node *)a)->hash,\n+\t\t\t &((const struct obj_index_tree_node *)b)->hash);\n+}\n+\n+static void writer_index_hash(struct reftable_writer *w, struct strbuf *hash)\n+{\n+\tuint64_t off = w->next;\n+\n+\tstruct obj_index_tree_node want = { .hash = *hash };\n+\n+\tstruct tree_node *node = tree_search(&want, &w->obj_index_tree,\n+\t\t\t\t\t &obj_index_tree_node_compare, 0);\n+\tstruct obj_index_tree_node *key = NULL;\n+\tif (node == NULL) {\n+\t\tstruct obj_index_tree_node empty = OBJ_INDEX_TREE_NODE_INIT;\n+\t\tkey = reftable_malloc(sizeof(struct obj_index_tree_node));\n+\t\t*key = empty;\n+\n+\t\tstrbuf_reset(&key->hash);\n+\t\ttree_search((void *)key, &w->obj_index_tree,\n+\t\t\t &obj_index_tree_node_compare, 1);\n+\t} else {\n+\t\tkey = node->key;\n+\t}\n+\n+\tif (key->offset_len > 0 && key->offsets[key->offset_len - 1] == off) {\n+\t\treturn;\n+\t}\n+\n+\tif (key->offset_len == key->offset_cap) {\n+\t\tkey->offset_cap = 2 * key->offset_cap + 1;\n+\t\tkey->offsets = reftable_realloc(\n+\t\t\tkey->offsets, sizeof(uint64_t) * key->offset_cap);\n+\t}\n+\n+\tkey->offsets[key->offset_len++] = off;\n+}\n+\n+\t\t\t struct reftable_record *rec)\n+{\n+\tint result = -1;\n+\tstruct strbuf key = STRBUF_INIT;\n+\tint err = 0;\n+\treftable_record_key(rec, &key);\n+\tif (strbuf_cmp(&w->last_key, &key) >= 0)\n+\t\tgoto done;\n+\n+\tstrbuf_reset(&w->last_key);\n+\tif (w->block_writer == NULL) {\n+\t\twriter_reinit_block_writer(w, reftable_record_type(rec));\n+\t}\n+\n+\tassert(block_writer_type(w->block_writer) == reftable_record_type(rec));\n+\n+\tif (block_writer_add(w->block_writer, rec) == 0) {\n+\t\tresult = 0;\n+\t\tgoto done;\n+\t}\n+\n+\terr = writer_flush_block(w);\n+\tif (err < 0) {\n+\t\tresult = err;\n+\t\tgoto done;\n+\t}\n+\n+\twriter_reinit_block_writer(w, reftable_record_type(rec));\n+\tif (err < 0) {\n+\t\tresult = err;\n+\t\tgoto done;\n+\t}\n+\n+\tresult = 0;\n+done:\n+\tstrbuf_release(&key);\n+\treturn result;\n+}\n+\n+\t\t\t struct reftable_ref_record *ref)\n+{\n+\tstruct reftable_record rec = { NULL };\n+\tstruct reftable_ref_record copy = *ref;\n+\tint err = 0;\n+\n+\tif (ref->refname == NULL)\n+\t\treturn REFTABLE_API_ERROR;\n+\tif (ref->update_index < w->min_update_index ||\n+\t ref->update_index > w->max_update_index)\n+\t\treturn REFTABLE_API_ERROR;\n+\n+\treftable_record_from_ref(&rec, &copy);\n+\tcopy.update_index -= w->min_update_index;\n+\tif (err < 0)\n+\t\treturn err;\n+\n+\tif (!w->opts.skip_index_objects && ref->value != NULL) {\n+\t\tstruct strbuf h = STRBUF_INIT;\n+\t\twriter_index_hash(w, &h);\n+\t\tstrbuf_release(&h);\n+\t}\n+\n+\tif (!w->opts.skip_index_objects && ref->target_value != NULL) {\n+\t\tstruct strbuf h = STRBUF_INIT;\n+\t\twriter_index_hash(w, &h);\n+\t\tstrbuf_release(&h);\n+\t}\n+\treturn 0;\n+}\n+\n+\t\t\t struct reftable_ref_record *refs, int n)\n+{\n+\tint err = 0;\n+\tint i = 0;\n+\tQSORT(refs, n, reftable_ref_record_compare_name);\n+\tfor (i = 0; err == 0 && i < n; i++) {\n+\t}\n+\treturn err;\n+}\n+\n+\t\t\t struct reftable_log_record *log)\n+{\n+\tstruct reftable_record rec = { NULL };\n+\tchar *input_log_message = log->message;\n+\tstruct strbuf cleaned_message = STRBUF_INIT;\n+\tint err;\n+\tif (log->refname == NULL)\n+\t\treturn REFTABLE_API_ERROR;\n+\n+\tif (w->block_writer != NULL &&\n+\t block_writer_type(w->block_writer) == BLOCK_TYPE_REF) {\n+\t\tint err = writer_finish_public_section(w);\n+\t\tif (err < 0)\n+\t\t\treturn err;\n+\t}\n+\n+\tif (!w->opts.exact_log_message && log->message != NULL) {\n+\t\twhile (cleaned_message.len &&\n+\t\t cleaned_message.buf[cleaned_message.len - 1] == '\\n')\n+\t\t\tstrbuf_setlen(&cleaned_message,\n+\t\t\t\t cleaned_message.len - 1);\n+\t\tif (strchr(cleaned_message.buf, '\\n')) {\n+\t\t\t// multiple lines not allowed.\n+\t\t\terr = REFTABLE_API_ERROR;\n+\t\t\tgoto done;\n+\t\t}\n+\t\tlog->message = cleaned_message.buf;\n+\t}\n+\n+\n+\treftable_record_from_log(&rec, log);\n+\n+done:\n+\tlog->message = input_log_message;\n+\tstrbuf_release(&cleaned_message);\n+\treturn err;\n+}\n+\n+\t\t\t struct reftable_log_record *logs, int n)\n+{\n+\tint err = 0;\n+\tint i = 0;\n+\tQSORT(logs, n, reftable_log_record_compare_key);\n+\tfor (i = 0; err == 0 && i < n; i++) {\n+\t}\n+\treturn err;\n+}\n+\n+static int writer_finish_section(struct reftable_writer *w)\n+{\n+\tuint8_t typ = block_writer_type(w->block_writer);\n+\tuint64_t index_start = 0;\n+\tint max_level = 0;\n+\tint threshold = w->opts.unpadded ? 1 : 3;\n+\tint before_blocks = w->stats.idx_stats.blocks;\n+\tint err = writer_flush_block(w);\n+\tint i = 0;\n+\tstruct reftable_block_stats *bstats = NULL;\n+\tif (err < 0)\n+\t\treturn err;\n+\n+\twhile (w->index_len > threshold) {\n+\t\tstruct reftable_index_record *idx = NULL;\n+\t\tint idx_len = 0;\n+\n+\t\tmax_level++;\n+\t\tindex_start = w->next;\n+\t\twriter_reinit_block_writer(w, BLOCK_TYPE_INDEX);\n+\n+\t\tidx = w->index;\n+\t\tidx_len = w->index_len;\n+\n+\t\tw->index = NULL;\n+\t\tw->index_len = 0;\n+\t\tw->index_cap = 0;\n+\t\tfor (i = 0; i < idx_len; i++) {\n+\t\t\tstruct reftable_record rec = { NULL };\n+\t\t\treftable_record_from_index(&rec, idx + i);\n+\t\t\tif (block_writer_add(w->block_writer, &rec) == 0) {\n+\t\t\t\tcontinue;\n+\t\t\t}\n+\n+\t\t\terr = writer_flush_block(w);\n+\t\t\tif (err < 0)\n+\t\t\t\treturn err;\n+\n+\t\t\twriter_reinit_block_writer(w, BLOCK_TYPE_INDEX);\n+\n+\t\t\tif (err != 0) {\n+\t\t\t\t/* write into fresh block should always succeed\n+\t\t\t\t */\n+\t\t\t\tabort();\n+\t\t\t}\n+\t\t}\n+\t\tfor (i = 0; i < idx_len; i++) {\n+\t\t\tstrbuf_release(&idx[i].last_key);\n+\t\t}\n+\t\treftable_free(idx);\n+\t}\n+\n+\twriter_clear_index(w);\n+\n+\terr = writer_flush_block(w);\n+\tif (err < 0)\n+\t\treturn err;\n+\n+\tbstats = writer_reftable_block_stats(w, typ);\n+\tbstats->index_blocks = w->stats.idx_stats.blocks - before_blocks;\n+\tbstats->index_offset = index_start;\n+\tbstats->max_index_level = max_level;\n+\n+\t/* Reinit lastKey, as the next section can start with any key. */\n+\tw->last_key.len = 0;\n+\n+\treturn 0;\n+}\n+\n+struct common_prefix_arg {\n+\tstruct strbuf *last;\n+\tint max;\n+};\n+\n+static void update_common(void *void_arg, void *key)\n+{\n+\tstruct common_prefix_arg *arg = (struct common_prefix_arg *)void_arg;\n+\tstruct obj_index_tree_node *entry = (struct obj_index_tree_node *)key;\n+\tif (arg->last != NULL) {\n+\t\tint n = common_prefix_size(&entry->hash, arg->last);\n+\t\tif (n > arg->max) {\n+\t\t\targ->max = n;\n+\t\t}\n+\t}\n+\targ->last = &entry->hash;\n+}\n+\n+struct write_record_arg {\n+\tstruct reftable_writer *w;\n+\tint err;\n+};\n+\n+static void write_object_record(void *void_arg, void *key)\n+{\n+\tstruct write_record_arg *arg = (struct write_record_arg *)void_arg;\n+\tstruct obj_index_tree_node *entry = (struct obj_index_tree_node *)key;\n+\tstruct reftable_obj_record obj_rec = {\n+\t\t.hash_prefix = (uint8_t *)entry->hash.buf,\n+\t\t.hash_prefix_len = arg->w->stats.object_id_len,\n+\t\t.offsets = entry->offsets,\n+\t\t.offset_len = entry->offset_len,\n+\t};\n+\tstruct reftable_record rec = { NULL };\n+\tif (arg->err < 0)\n+\t\tgoto done;\n+\n+\treftable_record_from_obj(&rec, &obj_rec);\n+\tif (arg->err == 0)\n+\t\tgoto done;\n+\n+\targ->err = writer_flush_block(arg->w);\n+\tif (arg->err < 0)\n+\t\tgoto done;\n+\n+\twriter_reinit_block_writer(arg->w, BLOCK_TYPE_OBJ);\n+\tif (arg->err == 0)\n+\t\tgoto done;\n+\tobj_rec.offset_len = 0;\n+\n+\t/* Should be able to write into a fresh block. */\n+\tassert(arg->err == 0);\n+\n+done:;\n+}\n+\n+static void object_record_free(void *void_arg, void *key)\n+{\n+\tstruct obj_index_tree_node *entry = (struct obj_index_tree_node *)key;\n+\n+\tFREE_AND_NULL(entry->offsets);\n+\tstrbuf_release(&entry->hash);\n+\treftable_free(entry);\n+}\n+\n+static int writer_dump_object_index(struct reftable_writer *w)\n+{\n+\tstruct write_record_arg closure = { .w = w };\n+\tstruct common_prefix_arg common = { NULL };\n+\tif (w->obj_index_tree != NULL) {\n+\t\tinfix_walk(w->obj_index_tree, &update_common, &common);\n+\t}\n+\tw->stats.object_id_len = common.max + 1;\n+\n+\twriter_reinit_block_writer(w, BLOCK_TYPE_OBJ);\n+\n+\tif (w->obj_index_tree != NULL) {\n+\t\tinfix_walk(w->obj_index_tree, &write_object_record, &closure);\n+\t}\n+\n+\tif (closure.err < 0)\n+\t\treturn closure.err;\n+\treturn writer_finish_section(w);\n+}\n+\n+static int writer_finish_public_section(struct reftable_writer *w)\n+{\n+\tuint8_t typ = 0;\n+\tint err = 0;\n+\n+\tif (w->block_writer == NULL)\n+\t\treturn 0;\n+\n+\ttyp = block_writer_type(w->block_writer);\n+\terr = writer_finish_section(w);\n+\tif (err < 0)\n+\t\treturn err;\n+\tif (typ == BLOCK_TYPE_REF && !w->opts.skip_index_objects &&\n+\t w->stats.ref_stats.index_blocks > 0) {\n+\t\terr = writer_dump_object_index(w);\n+\t\tif (err < 0)\n+\t\t\treturn err;\n+\t}\n+\n+\tif (w->obj_index_tree != NULL) {\n+\t\tinfix_walk(w->obj_index_tree, &object_record_free, NULL);\n+\t\ttree_free(w->obj_index_tree);\n+\t\tw->obj_index_tree = NULL;\n+\t}\n+\n+\tw->block_writer = NULL;\n+\treturn 0;\n+}\n+\n+int reftable_writer_close(struct reftable_writer *w)\n+{\n+\tuint8_t footer;\n+\tuint8_t *p = footer;\n+\tint err = writer_finish_public_section(w);\n+\tint empty_table = w->next == 0;\n+\tif (err != 0)\n+\t\tgoto done;\n+\tif (empty_table) {\n+\t\t/* Empty tables need a header anyway. */\n+\t\tif (err < 0)\n+\t\t\tgoto done;\n+\t}\n+\n+\tput_be64(p, w->stats.ref_stats.index_offset);\n+\tp += 8;\n+\tput_be64(p, (w->stats.obj_stats.offset) << 5 | w->stats.object_id_len);\n+\tp += 8;\n+\tput_be64(p, w->stats.obj_stats.index_offset);\n+\tp += 8;\n+\n+\tput_be64(p, w->stats.log_stats.offset);\n+\tp += 8;\n+\tput_be64(p, w->stats.log_stats.index_offset);\n+\tp += 8;\n+\n+\tput_be32(p, crc32(0, footer, p - footer));\n+\tp += 4;\n+\n+\terr = padded_write(w, footer, footer_size(writer_version(w)), 0);\n+\tif (err < 0)\n+\t\tgoto done;\n+\n+\tif (empty_table) {\n+\t\terr = REFTABLE_EMPTY_TABLE_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+done:\n+\t/* free up memory. */\n+\tblock_writer_clear(&w->block_writer_data);\n+\twriter_clear_index(w);\n+\tstrbuf_release(&w->last_key);\n+\treturn err;\n+}\n+\n+static void writer_clear_index(struct reftable_writer *w)\n+{\n+\tint i = 0;\n+\tfor (i = 0; i < w->index_len; i++) {\n+\t\tstrbuf_release(&w->index[i].last_key);\n+\t}\n+\n+\tFREE_AND_NULL(w->index);\n+\tw->index_len = 0;\n+\tw->index_cap = 0;\n+}\n+\n+static const int debug = 0;\n+\n+static int writer_flush_nonempty_block(struct reftable_writer *w)\n+{\n+\tuint8_t typ = block_writer_type(w->block_writer);\n+\tstruct reftable_block_stats *bstats =\n+\t\twriter_reftable_block_stats(w, typ);\n+\tuint64_t block_typ_off = (bstats->blocks == 0) ? w->next : 0;\n+\tint raw_bytes = block_writer_finish(w->block_writer);\n+\tint err = 0;\n+\tstruct reftable_index_record ir = { .last_key = STRBUF_INIT };\n+\tif (raw_bytes < 0)\n+\t\treturn raw_bytes;\n+\n+\tif (!w->opts.unpadded && typ != BLOCK_TYPE_LOG) {\n+\t\tpadding = w->opts.block_size - raw_bytes;\n+\t}\n+\n+\tif (block_typ_off > 0) {\n+\t\tbstats->offset = block_typ_off;\n+\t}\n+\n+\tbstats->entries += w->block_writer->entries;\n+\tbstats->restarts += w->block_writer->restart_len;\n+\tbstats->blocks++;\n+\tw->stats.blocks++;\n+\n+\tif (debug) {\n+\t\tfprintf(stderr, \"block %c off %\" PRIu64 \" sz %d (%d)\\n\", typ,\n+\t\t\tw->next, raw_bytes,\n+\t\t\tget_be24(w->block + w->block_writer->header_off + 1));\n+\t}\n+\n+\tif (w->next == 0) {\n+\t}\n+\n+\tif (err < 0)\n+\t\treturn err;\n+\n+\tif (w->index_cap == w->index_len) {\n+\t\tw->index_cap = 2 * w->index_cap + 1;\n+\t\tw->index = reftable_realloc(\n+\t\t\tw->index,\n+\t\t\tsizeof(struct reftable_index_record) * w->index_cap);\n+\t}\n+\n+\tir.offset = w->next;\n+\tstrbuf_reset(&ir.last_key);\n+\tw->index[w->index_len] = ir;\n+\n+\tw->index_len++;\n+\tw->next += padding + raw_bytes;\n+\tw->block_writer = NULL;\n+\treturn 0;\n+}\n+\n+static int writer_flush_block(struct reftable_writer *w)\n+{\n+\tif (w->block_writer == NULL)\n+\t\treturn 0;\n+\tif (w->block_writer->entries == 0)\n+\t\treturn 0;\n+\treturn writer_flush_nonempty_block(w);\n+}\n+\n+const struct reftable_stats *writer_stats(struct reftable_writer *w)\n+{\n+\treturn &w->stats;\n+}\ndiff --git a/reftable/writer.h b/reftable/writer.h\nnew file mode 100644\nindex 0000000000..06e0705a79\n--- /dev/null\n+++ b/reftable/writer.h\n@@ -0,0 +1,51 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#ifndef WRITER_H\n+#define WRITER_H\n+\n+#include \"basics.h\"\n+#include \"block.h\"\n+#include \"reftable.h\"\n+#include \"strbuf.h\"\n+#include \"tree.h\"\n+\n+struct reftable_writer {\n+\tint (*write)(void *, const void *, size_t);\n+\tvoid *write_arg;\n+\tstruct strbuf last_key;\n+\n+\t/* offset of next block to write. */\n+\tuint64_t next;\n+\tuint64_t min_update_index, max_update_index;\n+\tstruct reftable_write_options opts;\n+\n+\t/* memory buffer for writing */\n+\tuint8_t *block;\n+\n+\t/* writer for the current section. NULL or points to\n+\t * block_writer_data */\n+\tstruct block_writer *block_writer;\n+\n+\tstruct block_writer block_writer_data;\n+\n+\t/* pending index records for the current section */\n+\tstruct reftable_index_record *index;\n+\tsize_t index_len;\n+\tsize_t index_cap;\n+\n+\t/*\n+\t tree for use with tsearch; used to populate the 'o' inverse OID\n+\t map */\n+\tstruct tree_node *obj_index_tree;\n+\n+\tstruct reftable_stats stats;\n+};\n+\n+#endif\n--\n\n• ```* [PATCH v2 10/13] reftable: read reftable files\n2020-10-01 16:10 ` [PATCH v2 00/13] reftable library Han-Wen Nienhuys via GitGitGadget\n` (8 preceding siblings ...)\n2020-10-01 16:10 ` [PATCH v2 09/13] reftable: write reftable files Han-Wen Nienhuys via GitGitGadget\n@ 2020-10-01 16:11 ` Han-Wen Nienhuys via GitGitGadget\n2020-10-01 16:11 ` [PATCH v2 11/13] reftable: file level tests Han-Wen Nienhuys via GitGitGadget\n` (3 subsequent siblings)\n13 siblings, 0 replies; 251+ messages in thread\nFrom: Han-Wen Nienhuys via GitGitGadget @ 2020-10-01 16:11 UTC (permalink / raw)\nTo: git; +Cc: Han-Wen Nienhuys, Jeff King, Han-Wen Nienhuys, Han-Wen Nienhuys\n\n---\nMakefile | 3 +\nreftable/iter.c | 242 +++++++++++++++\nreftable/iter.h | 72 +++++\nreftable/reftable.c | 104 +++++++\n6 files changed, 1232 insertions(+)\ncreate mode 100644 reftable/iter.c\ncreate mode 100644 reftable/iter.h\ncreate mode 100644 reftable/reftable.c\n\ndiff --git a/Makefile b/Makefile\nindex c1dd046155..8b09a56d91 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -2377,7 +2377,10 @@ REFTABLE_OBJS += reftable/block.o\nREFTABLE_OBJS += reftable/blocksource.o\nREFTABLE_OBJS += reftable/publicbasics.o\nREFTABLE_OBJS += reftable/compat.o\n+REFTABLE_OBJS += reftable/iter.o\nREFTABLE_OBJS += reftable/record.o\n+REFTABLE_OBJS += reftable/reftable.o\nREFTABLE_OBJS += reftable/strbuf.o\nREFTABLE_OBJS += reftable/tree.o\nREFTABLE_OBJS += reftable/writer.o\ndiff --git a/reftable/iter.c b/reftable/iter.c\nnew file mode 100644\nindex 0000000000..2cff447323\n--- /dev/null\n+++ b/reftable/iter.c\n@@ -0,0 +1,242 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"iter.h\"\n+\n+#include \"system.h\"\n+\n+#include \"block.h\"\n+#include \"constants.h\"\n+#include \"reftable.h\"\n+\n+int iterator_is_null(struct reftable_iterator *it)\n+{\n+\treturn it->ops == NULL;\n+}\n+\n+static int empty_iterator_next(void *arg, struct reftable_record *rec)\n+{\n+\treturn 1;\n+}\n+\n+static void empty_iterator_close(void *arg)\n+{\n+}\n+\n+static struct reftable_iterator_vtable empty_vtable = {\n+\t.next = &empty_iterator_next,\n+\t.close = &empty_iterator_close,\n+};\n+\n+void iterator_set_empty(struct reftable_iterator *it)\n+{\n+\tassert(it->ops == NULL);\n+\tit->iter_arg = NULL;\n+\tit->ops = &empty_vtable;\n+}\n+\n+int iterator_next(struct reftable_iterator *it, struct reftable_record *rec)\n+{\n+\treturn it->ops->next(it->iter_arg, rec);\n+}\n+\n+void reftable_iterator_destroy(struct reftable_iterator *it)\n+{\n+\tif (it->ops == NULL) {\n+\t\treturn;\n+\t}\n+\tit->ops->close(it->iter_arg);\n+\tit->ops = NULL;\n+\tFREE_AND_NULL(it->iter_arg);\n+}\n+\n+int reftable_iterator_next_ref(struct reftable_iterator *it,\n+\t\t\t struct reftable_ref_record *ref)\n+{\n+\tstruct reftable_record rec = { 0 };\n+\treftable_record_from_ref(&rec, ref);\n+\treturn iterator_next(it, &rec);\n+}\n+\n+int reftable_iterator_next_log(struct reftable_iterator *it,\n+\t\t\t struct reftable_log_record *log)\n+{\n+\tstruct reftable_record rec = { 0 };\n+\treftable_record_from_log(&rec, log);\n+\treturn iterator_next(it, &rec);\n+}\n+\n+static void filtering_ref_iterator_close(void *iter_arg)\n+{\n+\tstruct filtering_ref_iterator *fri =\n+\t\t(struct filtering_ref_iterator *)iter_arg;\n+\tstrbuf_release(&fri->oid);\n+\treftable_iterator_destroy(&fri->it);\n+}\n+\n+static int filtering_ref_iterator_next(void *iter_arg,\n+\t\t\t\t struct reftable_record *rec)\n+{\n+\tstruct filtering_ref_iterator *fri =\n+\t\t(struct filtering_ref_iterator *)iter_arg;\n+\tstruct reftable_ref_record *ref =\n+\t\t(struct reftable_ref_record *)rec->data;\n+\tint err = 0;\n+\twhile (1) {\n+\t\terr = reftable_iterator_next_ref(&fri->it, ref);\n+\t\tif (err != 0) {\n+\t\t\tbreak;\n+\t\t}\n+\n+\t\tif (fri->double_check) {\n+\t\t\tstruct reftable_iterator it = { 0 };\n+\n+\t\t\terr = reftable_table_seek_ref(&fri->tab, &it,\n+\t\t\t\t\t\t ref->refname);\n+\t\t\tif (err == 0) {\n+\t\t\t\terr = reftable_iterator_next_ref(&it, ref);\n+\t\t\t}\n+\n+\t\t\treftable_iterator_destroy(&it);\n+\n+\t\t\tif (err < 0) {\n+\t\t\t\tbreak;\n+\t\t\t}\n+\n+\t\t\tif (err > 0) {\n+\t\t\t\tcontinue;\n+\t\t\t}\n+\t\t}\n+\n+\t\tif ((ref->target_value != NULL &&\n+\t\t !memcmp(fri->oid.buf, ref->target_value, fri->oid.len)) ||\n+\t\t (ref->value != NULL &&\n+\t\t !memcmp(fri->oid.buf, ref->value, fri->oid.len))) {\n+\t\t\treturn 0;\n+\t\t}\n+\t}\n+\n+\treftable_ref_record_clear(ref);\n+\treturn err;\n+}\n+\n+static struct reftable_iterator_vtable filtering_ref_iterator_vtable = {\n+\t.next = &filtering_ref_iterator_next,\n+\t.close = &filtering_ref_iterator_close,\n+};\n+\n+void iterator_from_filtering_ref_iterator(struct reftable_iterator *it,\n+\t\t\t\t\t struct filtering_ref_iterator *fri)\n+{\n+\tassert(it->ops == NULL);\n+\tit->iter_arg = fri;\n+\tit->ops = &filtering_ref_iterator_vtable;\n+}\n+\n+static void indexed_table_ref_iter_close(void *p)\n+{\n+\tstruct indexed_table_ref_iter *it = (struct indexed_table_ref_iter *)p;\n+\tblock_iter_close(&it->cur);\n+\tstrbuf_release(&it->oid);\n+}\n+\n+static int indexed_table_ref_iter_next_block(struct indexed_table_ref_iter *it)\n+{\n+\tuint64_t off;\n+\tint err = 0;\n+\tif (it->offset_idx == it->offset_len) {\n+\t\tit->is_finished = 1;\n+\t\treturn 1;\n+\t}\n+\n+\n+\toff = it->offsets[it->offset_idx++];\n+\t\t\t\t BLOCK_TYPE_REF);\n+\tif (err < 0) {\n+\t\treturn err;\n+\t}\n+\tif (err > 0) {\n+\t\t/* indexed block does not exist. */\n+\t\treturn REFTABLE_FORMAT_ERROR;\n+\t}\n+\treturn 0;\n+}\n+\n+static int indexed_table_ref_iter_next(void *p, struct reftable_record *rec)\n+{\n+\tstruct indexed_table_ref_iter *it = (struct indexed_table_ref_iter *)p;\n+\tstruct reftable_ref_record *ref =\n+\t\t(struct reftable_ref_record *)rec->data;\n+\n+\twhile (1) {\n+\t\tint err = block_iter_next(&it->cur, rec);\n+\t\tif (err < 0) {\n+\t\t\treturn err;\n+\t\t}\n+\n+\t\tif (err > 0) {\n+\t\t\terr = indexed_table_ref_iter_next_block(it);\n+\t\t\tif (err < 0) {\n+\t\t\t\treturn err;\n+\t\t\t}\n+\n+\t\t\tif (it->is_finished) {\n+\t\t\t\treturn 1;\n+\t\t\t}\n+\t\t\tcontinue;\n+\t\t}\n+\n+\t\tif (!memcmp(it->oid.buf, ref->target_value, it->oid.len) ||\n+\t\t !memcmp(it->oid.buf, ref->value, it->oid.len)) {\n+\t\t\treturn 0;\n+\t\t}\n+\t}\n+}\n+\n+int new_indexed_table_ref_iter(struct indexed_table_ref_iter **dest,\n+\t\t\t struct reftable_reader *r, uint8_t *oid,\n+\t\t\t int oid_len, uint64_t *offsets, int offset_len)\n+{\n+\tstruct indexed_table_ref_iter empty = INDEXED_TABLE_REF_ITER_INIT;\n+\tstruct indexed_table_ref_iter *itr =\n+\t\treftable_calloc(sizeof(struct indexed_table_ref_iter));\n+\tint err = 0;\n+\n+\t*itr = empty;\n+\titr->r = r;\n+\n+\titr->offsets = offsets;\n+\titr->offset_len = offset_len;\n+\n+\terr = indexed_table_ref_iter_next_block(itr);\n+\tif (err < 0) {\n+\t\treftable_free(itr);\n+\t} else {\n+\t\t*dest = itr;\n+\t}\n+\treturn err;\n+}\n+\n+static struct reftable_iterator_vtable indexed_table_ref_iter_vtable = {\n+\t.next = &indexed_table_ref_iter_next,\n+\t.close = &indexed_table_ref_iter_close,\n+};\n+\n+void iterator_from_indexed_table_ref_iter(struct reftable_iterator *it,\n+\t\t\t\t\t struct indexed_table_ref_iter *itr)\n+{\n+\tassert(it->ops == NULL);\n+\tit->iter_arg = itr;\n+\tit->ops = &indexed_table_ref_iter_vtable;\n+}\ndiff --git a/reftable/iter.h b/reftable/iter.h\nnew file mode 100644\nindex 0000000000..c92a178773\n--- /dev/null\n+++ b/reftable/iter.h\n@@ -0,0 +1,72 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#ifndef ITER_H\n+#define ITER_H\n+\n+#include \"block.h\"\n+#include \"record.h\"\n+#include \"strbuf.h\"\n+\n+struct reftable_iterator_vtable {\n+\tint (*next)(void *iter_arg, struct reftable_record *rec);\n+\tvoid (*close)(void *iter_arg);\n+};\n+\n+void iterator_set_empty(struct reftable_iterator *it);\n+int iterator_next(struct reftable_iterator *it, struct reftable_record *rec);\n+\n+/* Returns true for a zeroed out iterator, such as the one returned from\n+ iterator_destroy. */\n+int iterator_is_null(struct reftable_iterator *it);\n+\n+/* iterator that produces only ref records that point to `oid` */\n+struct filtering_ref_iterator {\n+\tint double_check;\n+\tstruct reftable_table tab;\n+\tstruct strbuf oid;\n+\tstruct reftable_iterator it;\n+};\n+#define FILTERING_REF_ITERATOR_INIT \\\n+\t{ \\\n+\t\t.oid = STRBUF_INIT \\\n+\t}\n+\n+void iterator_from_filtering_ref_iterator(struct reftable_iterator *,\n+\t\t\t\t\t struct filtering_ref_iterator *);\n+\n+/* iterator that produces only ref records that point to `oid`,\n+ but using the object index.\n+ */\n+struct indexed_table_ref_iter {\n+\tstruct strbuf oid;\n+\n+\t/* mutable */\n+\tuint64_t *offsets;\n+\n+\t/* Points to the next offset to read. */\n+\tint offset_idx;\n+\tint offset_len;\n+\tstruct block_iter cur;\n+\tint is_finished;\n+};\n+\n+#define INDEXED_TABLE_REF_ITER_INIT \\\n+\t{ \\\n+\t\t.cur = { .last_key = STRBUF_INIT }, .oid = STRBUF_INIT, \\\n+\t}\n+\n+void iterator_from_indexed_table_ref_iter(struct reftable_iterator *it,\n+\t\t\t\t\t struct indexed_table_ref_iter *itr);\n+int new_indexed_table_ref_iter(struct indexed_table_ref_iter **dest,\n+\t\t\t struct reftable_reader *r, uint8_t *oid,\n+\t\t\t int oid_len, uint64_t *offsets, int offset_len);\n+\n+#endif\nnew file mode 100644\nindex 0000000000..c7f56b5fdc\n--- /dev/null\n@@ -0,0 +1,733 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+\n+#include \"system.h\"\n+#include \"block.h\"\n+#include \"constants.h\"\n+#include \"iter.h\"\n+#include \"record.h\"\n+#include \"reftable.h\"\n+#include \"tree.h\"\n+\n+uint64_t block_source_size(struct reftable_block_source *source)\n+{\n+\treturn source->ops->size(source->arg);\n+}\n+\n+\t\t\t struct reftable_block *dest, uint64_t off,\n+\t\t\t uint32_t size)\n+{\n+\tint result = source->ops->read_block(source->arg, dest, off, size);\n+\tdest->source = *source;\n+\treturn result;\n+}\n+\n+void block_source_close(struct reftable_block_source *source)\n+{\n+\tif (source->ops == NULL) {\n+\t\treturn;\n+\t}\n+\n+\tsource->ops->close(source->arg);\n+\tsource->ops = NULL;\n+}\n+\n+{\n+\tswitch (typ) {\n+\tcase BLOCK_TYPE_REF:\n+\t\treturn &r->ref_offsets;\n+\tcase BLOCK_TYPE_LOG:\n+\t\treturn &r->log_offsets;\n+\tcase BLOCK_TYPE_OBJ:\n+\t\treturn &r->obj_offsets;\n+\t}\n+\tabort();\n+}\n+\n+\t\t\t struct reftable_block *dest, uint64_t off,\n+\t\t\t uint32_t sz)\n+{\n+\tif (off >= r->size)\n+\t\treturn 0;\n+\n+\tif (off + sz > r->size) {\n+\t\tsz = r->size - off;\n+\t}\n+\n+\treturn block_source_read_block(&r->source, dest, off, sz);\n+}\n+\n+{\n+\treturn r->hash_id;\n+}\n+\n+{\n+\treturn r->name;\n+}\n+\n+static int parse_footer(struct reftable_reader *r, uint8_t *footer,\n+{\n+\tuint8_t *f = footer;\n+\tuint8_t first_block_typ;\n+\tint err = 0;\n+\tuint32_t computed_crc;\n+\tuint32_t file_crc;\n+\n+\tif (memcmp(f, \"REFT\", 4)) {\n+\t\terr = REFTABLE_FORMAT_ERROR;\n+\t\tgoto done;\n+\t}\n+\tf += 4;\n+\n+\t\terr = REFTABLE_FORMAT_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+\tf++;\n+\tr->block_size = get_be24(f);\n+\n+\tf += 3;\n+\tr->min_update_index = get_be64(f);\n+\tf += 8;\n+\tr->max_update_index = get_be64(f);\n+\tf += 8;\n+\n+\tif (r->version == 1) {\n+\t\tr->hash_id = SHA1_ID;\n+\t} else {\n+\t\tr->hash_id = get_be32(f);\n+\t\tswitch (r->hash_id) {\n+\t\tcase SHA1_ID:\n+\t\t\tbreak;\n+\t\tcase SHA256_ID:\n+\t\t\tbreak;\n+\t\tdefault:\n+\t\t\terr = REFTABLE_FORMAT_ERROR;\n+\t\t\tgoto done;\n+\t\t}\n+\t\tf += 4;\n+\t}\n+\n+\tr->ref_offsets.index_offset = get_be64(f);\n+\tf += 8;\n+\n+\tr->obj_offsets.offset = get_be64(f);\n+\tf += 8;\n+\n+\tr->object_id_len = r->obj_offsets.offset & ((1 << 5) - 1);\n+\tr->obj_offsets.offset >>= 5;\n+\n+\tr->obj_offsets.index_offset = get_be64(f);\n+\tf += 8;\n+\tr->log_offsets.offset = get_be64(f);\n+\tf += 8;\n+\tr->log_offsets.index_offset = get_be64(f);\n+\tf += 8;\n+\n+\tcomputed_crc = crc32(0, footer, f - footer);\n+\tfile_crc = get_be32(f);\n+\tf += 4;\n+\tif (computed_crc != file_crc) {\n+\t\terr = REFTABLE_FORMAT_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+\tr->ref_offsets.is_present = (first_block_typ == BLOCK_TYPE_REF);\n+\tr->ref_offsets.offset = 0;\n+\tr->log_offsets.is_present = (first_block_typ == BLOCK_TYPE_LOG ||\n+\t\t\t\t r->log_offsets.offset > 0);\n+\tr->obj_offsets.is_present = r->obj_offsets.offset > 0;\n+\terr = 0;\n+done:\n+\treturn err;\n+}\n+\n+\t\tconst char *name)\n+{\n+\tstruct reftable_block footer = { 0 };\n+\tstruct reftable_block header = { 0 };\n+\tint err = 0;\n+\n+\n+\t/* Need +1 to read type of first block. */\n+\tif (err != header_size(2) + 1) {\n+\t\terr = REFTABLE_IO_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+\tif (memcmp(header.data, \"REFT\", 4)) {\n+\t\terr = REFTABLE_FORMAT_ERROR;\n+\t\tgoto done;\n+\t}\n+\tif (r->version != 1 && r->version != 2) {\n+\t\terr = REFTABLE_FORMAT_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+\tr->size = block_source_size(source) - footer_size(r->version);\n+\tr->source = *source;\n+\tr->name = xstrdup(name);\n+\tr->hash_id = 0;\n+\n+\terr = block_source_read_block(source, &footer, r->size,\n+\t\t\t\t footer_size(r->version));\n+\tif (err != footer_size(r->version)) {\n+\t\terr = REFTABLE_IO_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+\terr = parse_footer(r, footer.data, header.data);\n+done:\n+\treftable_block_done(&footer);\n+\treturn err;\n+}\n+\n+struct table_iter {\n+\tuint8_t typ;\n+\tuint64_t block_off;\n+\tstruct block_iter bi;\n+\tint is_finished;\n+};\n+#define TABLE_ITER_INIT \\\n+\t{ \\\n+\t\t.bi = {.last_key = STRBUF_INIT } \\\n+\t}\n+\n+static void table_iter_copy_from(struct table_iter *dest,\n+\t\t\t\t struct table_iter *src)\n+{\n+\tdest->r = src->r;\n+\tdest->typ = src->typ;\n+\tdest->block_off = src->block_off;\n+\tdest->is_finished = src->is_finished;\n+\tblock_iter_copy_from(&dest->bi, &src->bi);\n+}\n+\n+static int table_iter_next_in_block(struct table_iter *ti,\n+\t\t\t\t struct reftable_record *rec)\n+{\n+\tint res = block_iter_next(&ti->bi, rec);\n+\tif (res == 0 && reftable_record_type(rec) == BLOCK_TYPE_REF) {\n+\t\t((struct reftable_ref_record *)rec->data)->update_index +=\n+\t\t\tti->r->min_update_index;\n+\t}\n+\n+\treturn res;\n+}\n+\n+static void table_iter_block_done(struct table_iter *ti)\n+{\n+\tif (ti->bi.br == NULL) {\n+\t\treturn;\n+\t}\n+\treftable_block_done(&ti->bi.br->block);\n+\tFREE_AND_NULL(ti->bi.br);\n+\n+\tti->bi.last_key.len = 0;\n+\tti->bi.next_off = 0;\n+}\n+\n+static int32_t extract_block_size(uint8_t *data, uint8_t *typ, uint64_t off,\n+\t\t\t\t int version)\n+{\n+\tint32_t result = 0;\n+\n+\tif (off == 0) {\n+\t}\n+\n+\t*typ = data;\n+\tif (reftable_is_block_type(*typ)) {\n+\t\tresult = get_be24(data + 1);\n+\t}\n+\treturn result;\n+}\n+\n+\t\t\t uint64_t next_off, uint8_t want_typ)\n+{\n+\tint32_t guess_block_size = r->block_size ? r->block_size :\n+\t\t\t\t\t\t\t DEFAULT_BLOCK_SIZE;\n+\tstruct reftable_block block = { 0 };\n+\tuint8_t block_typ = 0;\n+\tint err = 0;\n+\tint32_t block_size = 0;\n+\n+\tif (next_off >= r->size)\n+\t\treturn 1;\n+\n+\terr = reader_get_block(r, &block, next_off, guess_block_size);\n+\tif (err < 0)\n+\t\treturn err;\n+\n+\tblock_size = extract_block_size(block.data, &block_typ, next_off,\n+\t\t\t\t\tr->version);\n+\tif (block_size < 0)\n+\t\treturn block_size;\n+\n+\tif (want_typ != BLOCK_TYPE_ANY && block_typ != want_typ) {\n+\t\treftable_block_done(&block);\n+\t\treturn 1;\n+\t}\n+\n+\tif (block_size > guess_block_size) {\n+\t\treftable_block_done(&block);\n+\t\terr = reader_get_block(r, &block, next_off, block_size);\n+\t\tif (err < 0) {\n+\t\t\treturn err;\n+\t\t}\n+\t}\n+\n+\t\t\t\t hash_size(r->hash_id));\n+}\n+\n+static int table_iter_next_block(struct table_iter *dest,\n+\t\t\t\t struct table_iter *src)\n+{\n+\tuint64_t next_block_off = src->block_off + src->bi.br->full_block_size;\n+\tstruct block_reader br = { 0 };\n+\tint err = 0;\n+\n+\tdest->r = src->r;\n+\tdest->typ = src->typ;\n+\tdest->block_off = next_block_off;\n+\n+\tif (err > 0) {\n+\t\tdest->is_finished = 1;\n+\t\treturn 1;\n+\t}\n+\tif (err != 0)\n+\t\treturn err;\n+\telse {\n+\t\t*brp = br;\n+\n+\t\tdest->is_finished = 0;\n+\t}\n+\treturn 0;\n+}\n+\n+static int table_iter_next(struct table_iter *ti, struct reftable_record *rec)\n+{\n+\tif (reftable_record_type(rec) != ti->typ)\n+\t\treturn REFTABLE_API_ERROR;\n+\n+\twhile (1) {\n+\t\tstruct table_iter next = TABLE_ITER_INIT;\n+\t\tint err = 0;\n+\t\tif (ti->is_finished) {\n+\t\t\treturn 1;\n+\t\t}\n+\n+\t\terr = table_iter_next_in_block(ti, rec);\n+\t\tif (err <= 0) {\n+\t\t\treturn err;\n+\t\t}\n+\n+\t\terr = table_iter_next_block(&next, ti);\n+\t\tif (err != 0) {\n+\t\t\tti->is_finished = 1;\n+\t\t}\n+\t\ttable_iter_block_done(ti);\n+\t\tif (err != 0) {\n+\t\t\treturn err;\n+\t\t}\n+\t\ttable_iter_copy_from(ti, &next);\n+\t\tblock_iter_close(&next.bi);\n+\t}\n+}\n+\n+static int table_iter_next_void(void *ti, struct reftable_record *rec)\n+{\n+\treturn table_iter_next((struct table_iter *)ti, rec);\n+}\n+\n+static void table_iter_close(void *p)\n+{\n+\tstruct table_iter *ti = (struct table_iter *)p;\n+\ttable_iter_block_done(ti);\n+\tblock_iter_close(&ti->bi);\n+}\n+\n+static struct reftable_iterator_vtable table_iter_vtable = {\n+\t.next = &table_iter_next_void,\n+\t.close = &table_iter_close,\n+};\n+\n+static void iterator_from_table_iter(struct reftable_iterator *it,\n+\t\t\t\t struct table_iter *ti)\n+{\n+\tassert(it->ops == NULL);\n+\tit->iter_arg = ti;\n+\tit->ops = &table_iter_vtable;\n+}\n+\n+\t\t\t\tstruct table_iter *ti, uint64_t off,\n+\t\t\t\tuint8_t typ)\n+{\n+\tstruct block_reader br = { 0 };\n+\tstruct block_reader *brp = NULL;\n+\n+\tif (err != 0)\n+\t\treturn err;\n+\n+\t*brp = br;\n+\tti->r = r;\n+\tti->block_off = off;\n+\treturn 0;\n+}\n+\n+\t\t\tuint8_t typ, int index)\n+{\n+\tuint64_t off = offs->offset;\n+\tif (index) {\n+\t\toff = offs->index_offset;\n+\t\tif (off == 0) {\n+\t\t\treturn 1;\n+\t\t}\n+\t\ttyp = BLOCK_TYPE_INDEX;\n+\t}\n+\n+\treturn reader_table_iter_at(r, ti, off, typ);\n+}\n+\n+\t\t\t struct reftable_record *want)\n+{\n+\tstruct reftable_record rec =\n+\t\treftable_new_record(reftable_record_type(want));\n+\tstruct strbuf want_key = STRBUF_INIT;\n+\tstruct strbuf got_key = STRBUF_INIT;\n+\tstruct table_iter next = TABLE_ITER_INIT;\n+\tint err = -1;\n+\n+\treftable_record_key(want, &want_key);\n+\n+\twhile (1) {\n+\t\terr = table_iter_next_block(&next, ti);\n+\t\tif (err < 0)\n+\t\t\tgoto done;\n+\n+\t\tif (err > 0) {\n+\t\t\tbreak;\n+\t\t}\n+\n+\t\tif (err < 0)\n+\t\t\tgoto done;\n+\n+\t\tif (strbuf_cmp(&got_key, &want_key) > 0) {\n+\t\t\ttable_iter_block_done(&next);\n+\t\t\tbreak;\n+\t\t}\n+\n+\t\ttable_iter_block_done(ti);\n+\t\ttable_iter_copy_from(ti, &next);\n+\t}\n+\n+\terr = block_iter_seek(&ti->bi, &want_key);\n+\tif (err < 0)\n+\t\tgoto done;\n+\terr = 0;\n+\n+done:\n+\tblock_iter_close(&next.bi);\n+\treftable_record_destroy(&rec);\n+\tstrbuf_release(&want_key);\n+\tstrbuf_release(&got_key);\n+\treturn err;\n+}\n+\n+\t\t\t struct reftable_iterator *it,\n+\t\t\t struct reftable_record *rec)\n+{\n+\tstruct reftable_index_record want_index = { .last_key = STRBUF_INIT };\n+\tstruct reftable_record want_index_rec = { 0 };\n+\tstruct reftable_index_record index_result = { .last_key = STRBUF_INIT };\n+\tstruct reftable_record index_result_rec = { 0 };\n+\tstruct table_iter index_iter = TABLE_ITER_INIT;\n+\tstruct table_iter next = TABLE_ITER_INIT;\n+\tint err = 0;\n+\n+\treftable_record_key(rec, &want_index.last_key);\n+\treftable_record_from_index(&want_index_rec, &want_index);\n+\treftable_record_from_index(&index_result_rec, &index_result);\n+\n+\terr = reader_start(r, &index_iter, reftable_record_type(rec), 1);\n+\tif (err < 0)\n+\t\tgoto done;\n+\n+\terr = reader_seek_linear(r, &index_iter, &want_index_rec);\n+\twhile (1) {\n+\t\terr = table_iter_next(&index_iter, &index_result_rec);\n+\t\ttable_iter_block_done(&index_iter);\n+\t\tif (err != 0)\n+\t\t\tgoto done;\n+\n+\t\terr = reader_table_iter_at(r, &next, index_result.offset, 0);\n+\t\tif (err != 0)\n+\t\t\tgoto done;\n+\n+\t\terr = block_iter_seek(&next.bi, &want_index.last_key);\n+\t\tif (err < 0)\n+\t\t\tgoto done;\n+\n+\t\tif (next.typ == reftable_record_type(rec)) {\n+\t\t\terr = 0;\n+\t\t\tbreak;\n+\t\t}\n+\n+\t\tif (next.typ != BLOCK_TYPE_INDEX) {\n+\t\t\terr = REFTABLE_FORMAT_ERROR;\n+\t\t\tbreak;\n+\t\t}\n+\n+\t\ttable_iter_copy_from(&index_iter, &next);\n+\t}\n+\n+\tif (err == 0) {\n+\t\tstruct table_iter empty = TABLE_ITER_INIT;\n+\t\tstruct table_iter *malloced =\n+\t\t\treftable_calloc(sizeof(struct table_iter));\n+\t\t*malloced = empty;\n+\t\ttable_iter_copy_from(malloced, &next);\n+\t\titerator_from_table_iter(it, malloced);\n+\t}\n+done:\n+\tblock_iter_close(&next.bi);\n+\ttable_iter_close(&index_iter);\n+\treftable_record_clear(&want_index_rec);\n+\treftable_record_clear(&index_result_rec);\n+\treturn err;\n+}\n+\n+\t\t\t\tstruct reftable_iterator *it,\n+\t\t\t\tstruct reftable_record *rec)\n+{\n+\tuint64_t idx = offs->index_offset;\n+\tstruct table_iter ti = TABLE_ITER_INIT;\n+\tint err = 0;\n+\tif (idx > 0)\n+\n+\terr = reader_start(r, &ti, reftable_record_type(rec), 0);\n+\tif (err < 0)\n+\t\treturn err;\n+\terr = reader_seek_linear(r, &ti, rec);\n+\tif (err < 0)\n+\t\treturn err;\n+\telse {\n+\t\tstruct table_iter *p =\n+\t\t\treftable_malloc(sizeof(struct table_iter));\n+\t\t*p = ti;\n+\t\titerator_from_table_iter(it, p);\n+\t}\n+\n+\treturn 0;\n+}\n+\n+\t\tstruct reftable_record *rec)\n+{\n+\tuint8_t typ = reftable_record_type(rec);\n+\n+\tif (!offs->is_present) {\n+\t\titerator_set_empty(it);\n+\t\treturn 0;\n+\t}\n+\n+}\n+\n+\t\t\t struct reftable_iterator *it, const char *name)\n+{\n+\tstruct reftable_ref_record ref = {\n+\t\t.refname = (char *)name,\n+\t};\n+\tstruct reftable_record rec = { 0 };\n+\treftable_record_from_ref(&rec, &ref);\n+}\n+\n+\t\t\t\tstruct reftable_iterator *it, const char *name,\n+\t\t\t\tuint64_t update_index)\n+{\n+\tstruct reftable_log_record log = {\n+\t\t.refname = (char *)name,\n+\t\t.update_index = update_index,\n+\t};\n+\tstruct reftable_record rec = { 0 };\n+\treftable_record_from_log(&rec, &log);\n+}\n+\n+\t\t\t struct reftable_iterator *it, const char *name)\n+{\n+\tuint64_t max = ~((uint64_t)0);\n+\treturn reftable_reader_seek_log_at(r, it, name, max);\n+}\n+\n+{\n+\tblock_source_close(&r->source);\n+\tFREE_AND_NULL(r->name);\n+}\n+\n+\t\t\tstruct reftable_block_source *src, char const *name)\n+{\n+\tint err = init_reader(rd, src, name);\n+\tif (err == 0) {\n+\t\t*p = rd;\n+\t} else {\n+\t\tblock_source_close(src);\n+\t\treftable_free(rd);\n+\t}\n+\treturn err;\n+}\n+\n+{\n+\treftable_free(r);\n+}\n+\n+\t\t\t\t\t struct reftable_iterator *it,\n+\t\t\t\t\t uint8_t *oid)\n+{\n+\tstruct reftable_obj_record want = {\n+\t\t.hash_prefix = oid,\n+\t\t.hash_prefix_len = r->object_id_len,\n+\t};\n+\tstruct reftable_record want_rec = { 0 };\n+\tstruct reftable_iterator oit = { 0 };\n+\tstruct reftable_obj_record got = { 0 };\n+\tstruct reftable_record got_rec = { 0 };\n+\tint err = 0;\n+\tstruct indexed_table_ref_iter *itr = NULL;\n+\n+\t/* Look through the reverse index. */\n+\treftable_record_from_obj(&want_rec, &want);\n+\terr = reader_seek(r, &oit, &want_rec);\n+\tif (err != 0)\n+\t\tgoto done;\n+\n+\t/* read out the reftable_obj_record */\n+\treftable_record_from_obj(&got_rec, &got);\n+\terr = iterator_next(&oit, &got_rec);\n+\tif (err < 0)\n+\t\tgoto done;\n+\n+\tif (err > 0 ||\n+\t memcmp(want.hash_prefix, got.hash_prefix, r->object_id_len)) {\n+\t\t/* didn't find it; return empty iterator */\n+\t\titerator_set_empty(it);\n+\t\terr = 0;\n+\t\tgoto done;\n+\t}\n+\n+\terr = new_indexed_table_ref_iter(&itr, r, oid, hash_size(r->hash_id),\n+\t\t\t\t\t got.offsets, got.offset_len);\n+\tif (err < 0)\n+\t\tgoto done;\n+\tgot.offsets = NULL;\n+\titerator_from_indexed_table_ref_iter(it, itr);\n+\n+done:\n+\treftable_iterator_destroy(&oit);\n+\treftable_record_clear(&got_rec);\n+\treturn err;\n+}\n+\n+\t\t\t\t\t struct reftable_iterator *it,\n+\t\t\t\t\t uint8_t *oid)\n+{\n+\tstruct table_iter ti_empty = TABLE_ITER_INIT;\n+\tstruct table_iter *ti = reftable_calloc(sizeof(struct table_iter));\n+\tstruct filtering_ref_iterator *filter = NULL;\n+\tstruct filtering_ref_iterator empty = FILTERING_REF_ITERATOR_INIT;\n+\tint oid_len = hash_size(r->hash_id);\n+\tint err;\n+\n+\t*ti = ti_empty;\n+\terr = reader_start(r, ti, BLOCK_TYPE_REF, 0);\n+\tif (err < 0) {\n+\t\treftable_free(ti);\n+\t\treturn err;\n+\t}\n+\n+\tfilter = reftable_malloc(sizeof(struct filtering_ref_iterator));\n+\t*filter = empty;\n+\n+\tfilter->double_check = 0;\n+\titerator_from_table_iter(&filter->it, ti);\n+\n+\titerator_from_filtering_ref_iterator(it, filter);\n+\treturn 0;\n+}\n+\n+\t\t\t struct reftable_iterator *it, uint8_t *oid)\n+{\n+\tif (r->obj_offsets.is_present)\n+}\n+\n+{\n+\treturn r->max_update_index;\n+}\n+\n+{\n+\treturn r->min_update_index;\n+}\nnew file mode 100644\nindex 0000000000..8170258881\n--- /dev/null\n@@ -0,0 +1,78 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+\n+#include \"block.h\"\n+#include \"record.h\"\n+#include \"reftable.h\"\n+\n+uint64_t block_source_size(struct reftable_block_source *source);\n+\n+\t\t\t struct reftable_block *dest, uint64_t off,\n+\t\t\t uint32_t size);\n+void block_source_close(struct reftable_block_source *source);\n+\n+/* metadata for a block type */\n+\tint is_present;\n+\tuint64_t offset;\n+\tuint64_t index_offset;\n+};\n+\n+/* The state for reading a reftable file. */\n+\t/* for convience, associate a name with the instance. */\n+\tchar *name;\n+\tstruct reftable_block_source source;\n+\n+\t/* Size of the file, excluding the footer. */\n+\tuint64_t size;\n+\n+\t/* 'sha1' for SHA1, 's256' for SHA-256 */\n+\tuint32_t hash_id;\n+\n+\tuint32_t block_size;\n+\tuint64_t min_update_index;\n+\tuint64_t max_update_index;\n+\t/* Length of the OID keys in the 'o' section */\n+\tint object_id_len;\n+\tint version;\n+\n+};\n+\n+\t\tconst char *name);\n+\t\tstruct reftable_record *rec);\n+\n+\t\t\t uint64_t next_off, uint8_t want_typ);\n+\n+/* generic interface to reftables */\n+struct reftable_table_vtable {\n+\tint (*seek_record)(void *tab, struct reftable_iterator *it,\n+\t\t\t struct reftable_record *);\n+\tuint32_t (*hash_id)(void *tab);\n+\tuint64_t (*min_update_index)(void *tab);\n+\tuint64_t (*max_update_index)(void *tab);\n+};\n+\n+int reftable_table_seek_record(struct reftable_table *tab,\n+\t\t\t struct reftable_iterator *it,\n+\t\t\t struct reftable_record *rec);\n+\n+#endif\ndiff --git a/reftable/reftable.c b/reftable/reftable.c\nnew file mode 100644\nindex 0000000000..1425aef6f2\n--- /dev/null\n+++ b/reftable/reftable.c\n@@ -0,0 +1,104 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"reftable.h\"\n+#include \"record.h\"\n+\n+static int reftable_reader_seek_void(void *tab, struct reftable_iterator *it,\n+\t\t\t\t struct reftable_record *rec)\n+{\n+}\n+\n+{\n+}\n+\n+{\n+}\n+\n+{\n+}\n+\n+static struct reftable_table_vtable reader_vtable = {\n+};\n+\n+int reftable_table_seek_ref(struct reftable_table *tab,\n+\t\t\t struct reftable_iterator *it, const char *name)\n+{\n+\tstruct reftable_ref_record ref = {\n+\t\t.refname = (char *)name,\n+\t};\n+\tstruct reftable_record rec = { 0 };\n+\treftable_record_from_ref(&rec, &ref);\n+\treturn tab->ops->seek_record(tab->table_arg, it, &rec);\n+}\n+\n+{\n+\tassert(tab->ops == NULL);\n+}\n+\n+int reftable_table_read_ref(struct reftable_table *tab, const char *name,\n+\t\t\t struct reftable_ref_record *ref)\n+{\n+\tstruct reftable_iterator it = { 0 };\n+\tint err = reftable_table_seek_ref(tab, &it, name);\n+\tif (err)\n+\t\tgoto done;\n+\n+\terr = reftable_iterator_next_ref(&it, ref);\n+\tif (err)\n+\t\tgoto done;\n+\n+\tif (strcmp(ref->refname, name) ||\n+\t reftable_ref_record_is_deletion(ref)) {\n+\t\treftable_ref_record_clear(ref);\n+\t\terr = 1;\n+\t\tgoto done;\n+\t}\n+\n+done:\n+\treftable_iterator_destroy(&it);\n+\treturn err;\n+}\n+\n+int reftable_table_seek_record(struct reftable_table *tab,\n+\t\t\t struct reftable_iterator *it,\n+\t\t\t struct reftable_record *rec)\n+{\n+\treturn tab->ops->seek_record(tab->table_arg, it, rec);\n+}\n+\n+uint64_t reftable_table_max_update_index(struct reftable_table *tab)\n+{\n+\treturn tab->ops->max_update_index(tab->table_arg);\n+}\n+\n+uint64_t reftable_table_min_update_index(struct reftable_table *tab)\n+{\n+\treturn tab->ops->min_update_index(tab->table_arg);\n+}\n+\n+uint32_t reftable_table_hash_id(struct reftable_table *tab)\n+{\n+\treturn tab->ops->hash_id(tab->table_arg);\n+}\n--\n\n• ```* [PATCH v2 11/13] reftable: file level tests\n2020-10-01 16:10 ` [PATCH v2 00/13] reftable library Han-Wen Nienhuys via GitGitGadget\n` (9 preceding siblings ...)\n2020-10-01 16:11 ` [PATCH v2 10/13] reftable: read \" Han-Wen Nienhuys via GitGitGadget\n@ 2020-10-01 16:11 ` Han-Wen Nienhuys via GitGitGadget\n2020-10-01 16:11 ` [PATCH v2 12/13] reftable: rest of library Han-Wen Nienhuys via GitGitGadget\n` (2 subsequent siblings)\n13 siblings, 0 replies; 251+ messages in thread\nFrom: Han-Wen Nienhuys via GitGitGadget @ 2020-10-01 16:11 UTC (permalink / raw)\nTo: git; +Cc: Han-Wen Nienhuys, Jeff King, Han-Wen Nienhuys, Han-Wen Nienhuys\n\n---\nMakefile | 1 +\nreftable/reftable_test.c | 585 +++++++++++++++++++++++++++++++++++++++\nt/helper/test-reftable.c | 1 +\n3 files changed, 587 insertions(+)\ncreate mode 100644 reftable/reftable_test.c\n\ndiff --git a/Makefile b/Makefile\nindex 8b09a56d91..17d5fba0a0 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -2388,6 +2388,7 @@ REFTABLE_OBJS += reftable/zlib-compat.o\n\nREFTABLE_TEST_OBJS += reftable/block_test.o\nREFTABLE_TEST_OBJS += reftable/record_test.o\n+REFTABLE_TEST_OBJS += reftable/reftable_test.o\nREFTABLE_TEST_OBJS += reftable/strbuf_test.o\nREFTABLE_TEST_OBJS += reftable/test_framework.o\nREFTABLE_TEST_OBJS += reftable/tree_test.o\ndiff --git a/reftable/reftable_test.c b/reftable/reftable_test.c\nnew file mode 100644\nindex 0000000000..9fea692905\n--- /dev/null\n+++ b/reftable/reftable_test.c\n@@ -0,0 +1,585 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"reftable.h\"\n+\n+#include \"system.h\"\n+\n+#include \"basics.h\"\n+#include \"block.h\"\n+#include \"blocksource.h\"\n+#include \"constants.h\"\n+#include \"record.h\"\n+#include \"test_framework.h\"\n+#include \"reftable-tests.h\"\n+\n+static const int update_index = 5;\n+\n+static void test_buffer(void)\n+{\n+\tstruct strbuf buf = STRBUF_INIT;\n+\tstruct reftable_block_source source = { NULL };\n+\tstruct reftable_block out = { NULL };\n+\tint n;\n+\tuint8_t in[] = \"hello\";\n+\tblock_source_from_strbuf(&source, &buf);\n+\tassert(block_source_size(&source) == 6);\n+\tn = block_source_read_block(&source, &out, 0, sizeof(in));\n+\tassert(n == sizeof(in));\n+\tassert(!memcmp(in, out.data, n));\n+\treftable_block_done(&out);\n+\n+\tn = block_source_read_block(&source, &out, 1, 2);\n+\tassert(n == 2);\n+\tassert(!memcmp(out.data, \"el\", 2));\n+\n+\treftable_block_done(&out);\n+\tblock_source_close(&source);\n+\tstrbuf_release(&buf);\n+}\n+\n+static void write_table(char ***names, struct strbuf *buf, int N,\n+\t\t\tint block_size, uint32_t hash_id)\n+{\n+\tstruct reftable_write_options opts = {\n+\t\t.block_size = block_size,\n+\t\t.hash_id = hash_id,\n+\t};\n+\tstruct reftable_writer *w =\n+\tstruct reftable_ref_record ref = { NULL };\n+\tint i = 0, n;\n+\tstruct reftable_log_record log = { NULL };\n+\tconst struct reftable_stats *stats = NULL;\n+\t*names = reftable_calloc(sizeof(char *) * (N + 1));\n+\treftable_writer_set_limits(w, update_index, update_index);\n+\tfor (i = 0; i < N; i++) {\n+\t\tuint8_t hash[SHA256_SIZE] = { 0 };\n+\t\tchar name;\n+\t\tint n;\n+\n+\t\tset_test_hash(hash, i);\n+\n+\n+\t\tref.refname = name;\n+\t\tref.value = hash;\n+\t\tref.update_index = update_index;\n+\t\t(*names)[i] = xstrdup(name);\n+\n+\t\tassert(n == 0);\n+\t}\n+\n+\tfor (i = 0; i < N; i++) {\n+\t\tuint8_t hash[SHA256_SIZE] = { 0 };\n+\t\tchar name;\n+\t\tint n;\n+\n+\t\tset_test_hash(hash, i);\n+\n+\n+\t\tlog.refname = name;\n+\t\tlog.new_hash = hash;\n+\t\tlog.update_index = update_index;\n+\t\tlog.message = \"message\";\n+\n+\t\tassert(n == 0);\n+\t}\n+\n+\tn = reftable_writer_close(w);\n+\tassert(n == 0);\n+\n+\tstats = writer_stats(w);\n+\tfor (i = 0; i < stats->ref_stats.blocks; i++) {\n+\t\tint off = i * opts.block_size;\n+\t\tif (off == 0) {\n+\t\t\toff = header_size((hash_id == SHA256_ID) ? 2 : 1);\n+\t\t}\n+\t\tassert(buf->buf[off] == 'r');\n+\t}\n+\n+\tassert(stats->log_stats.blocks > 0);\n+\treftable_writer_free(w);\n+}\n+\n+static void test_log_buffer_size(void)\n+{\n+\tstruct strbuf buf = STRBUF_INIT;\n+\tstruct reftable_write_options opts = {\n+\t\t.block_size = 4096,\n+\t};\n+\tint err;\n+\tstruct reftable_log_record log = {\n+\t\t.name = \"Han-Wen Nienhuys\",\n+\t\t.tz_offset = 100,\n+\t\t.time = 0x5e430672,\n+\t\t.update_index = 0xa,\n+\t\t.message = \"commit: 9\\n\",\n+\t};\n+\tstruct reftable_writer *w =\n+\n+\t/* This tests buffer extension for log compression. Must use a random\n+\t hash, to ensure that the compressed part is larger than the original.\n+\t*/\n+\tuint8_t hash1[SHA1_SIZE], hash2[SHA1_SIZE];\n+\tfor (int i = 0; i < SHA1_SIZE; i++) {\n+\t\thash1[i] = (uint8_t)(rand() % 256);\n+\t\thash2[i] = (uint8_t)(rand() % 256);\n+\t}\n+\tlog.old_hash = hash1;\n+\tlog.new_hash = hash2;\n+\treftable_writer_set_limits(w, update_index, update_index);\n+\tassert_err(err);\n+\terr = reftable_writer_close(w);\n+\tassert_err(err);\n+\treftable_writer_free(w);\n+\tstrbuf_release(&buf);\n+}\n+\n+{\n+\tint N = 2;\n+\tchar **names = reftable_calloc(sizeof(char *) * (N + 1));\n+\tint err;\n+\tstruct reftable_write_options opts = {\n+\t\t.block_size = 256,\n+\t};\n+\tstruct reftable_ref_record ref = { NULL };\n+\tint i = 0;\n+\tstruct reftable_log_record log = { NULL };\n+\tint n;\n+\tstruct reftable_iterator it = { NULL };\n+\tstruct reftable_reader rd = { NULL };\n+\tstruct reftable_block_source source = { NULL };\n+\tstruct strbuf buf = STRBUF_INIT;\n+\tstruct reftable_writer *w =\n+\tconst struct reftable_stats *stats = NULL;\n+\treftable_writer_set_limits(w, 0, N);\n+\tfor (i = 0; i < N; i++) {\n+\t\tchar name;\n+\t\tstruct reftable_ref_record ref = { NULL };\n+\t\tsnprintf(name, sizeof(name), \"b%02d%0*d\", i, 130, 7);\n+\t\tnames[i] = xstrdup(name);\n+\t\tref.refname = name;\n+\t\tref.update_index = i;\n+\n+\t\tassert_err(err);\n+\t}\n+\tfor (i = 0; i < N; i++) {\n+\t\tuint8_t hash1[SHA1_SIZE], hash2[SHA1_SIZE];\n+\t\tstruct reftable_log_record log = { NULL };\n+\t\tset_test_hash(hash1, i);\n+\t\tset_test_hash(hash2, i + 1);\n+\n+\t\tlog.refname = names[i];\n+\t\tlog.update_index = i;\n+\t\tlog.old_hash = hash1;\n+\t\tlog.new_hash = hash2;\n+\n+\t\tassert_err(err);\n+\t}\n+\n+\tn = reftable_writer_close(w);\n+\tassert(n == 0);\n+\n+\tstats = writer_stats(w);\n+\tassert(stats->log_stats.blocks > 0);\n+\treftable_writer_free(w);\n+\tw = NULL;\n+\n+\tblock_source_from_strbuf(&source, &buf);\n+\n+\terr = init_reader(&rd, &source, \"file.log\");\n+\tassert_err(err);\n+\n+\terr = reftable_reader_seek_ref(&rd, &it, names[N - 1]);\n+\tassert_err(err);\n+\n+\terr = reftable_iterator_next_ref(&it, &ref);\n+\tassert_err(err);\n+\n+\t/* end of iteration. */\n+\terr = reftable_iterator_next_ref(&it, &ref);\n+\tassert(0 < err);\n+\n+\treftable_iterator_destroy(&it);\n+\treftable_ref_record_clear(&ref);\n+\n+\terr = reftable_reader_seek_log(&rd, &it, \"\");\n+\tassert_err(err);\n+\n+\ti = 0;\n+\twhile (1) {\n+\t\tint err = reftable_iterator_next_log(&it, &log);\n+\t\tif (err > 0) {\n+\t\t\tbreak;\n+\t\t}\n+\n+\t\tassert_err(err);\n+\t\tassert_streq(names[i], log.refname);\n+\t\tassert(i == log.update_index);\n+\t\ti++;\n+\t\treftable_log_record_clear(&log);\n+\t}\n+\n+\tassert(i == N);\n+\treftable_iterator_destroy(&it);\n+\n+\t/* cleanup. */\n+\tstrbuf_release(&buf);\n+\tfree_names(names);\n+}\n+\n+{\n+\tchar **names;\n+\tstruct strbuf buf = STRBUF_INIT;\n+\tint N = 50;\n+\tstruct reftable_iterator it = { NULL };\n+\tstruct reftable_block_source source = { NULL };\n+\tstruct reftable_reader rd = { NULL };\n+\tint err = 0;\n+\tint j = 0;\n+\n+\twrite_table(&names, &buf, N, 256, SHA1_ID);\n+\n+\tblock_source_from_strbuf(&source, &buf);\n+\n+\terr = init_reader(&rd, &source, \"file.ref\");\n+\tassert_err(err);\n+\n+\terr = reftable_reader_seek_ref(&rd, &it, \"\");\n+\tassert_err(err);\n+\n+\twhile (1) {\n+\t\tstruct reftable_ref_record ref = { NULL };\n+\t\tint r = reftable_iterator_next_ref(&it, &ref);\n+\t\tassert(r >= 0);\n+\t\tif (r > 0) {\n+\t\t\tbreak;\n+\t\t}\n+\t\tassert(0 == strcmp(names[j], ref.refname));\n+\t\tassert(update_index == ref.update_index);\n+\n+\t\tj++;\n+\t\treftable_ref_record_clear(&ref);\n+\t}\n+\tassert(j == N);\n+\treftable_iterator_destroy(&it);\n+\tstrbuf_release(&buf);\n+\tfree_names(names);\n+\n+}\n+\n+static void test_table_write_small_table(void)\n+{\n+\tchar **names;\n+\tstruct strbuf buf = STRBUF_INIT;\n+\tint N = 1;\n+\twrite_table(&names, &buf, N, 4096, SHA1_ID);\n+\tassert(buf.len < 200);\n+\tstrbuf_release(&buf);\n+\tfree_names(names);\n+}\n+\n+{\n+\tchar **names;\n+\tstruct strbuf buf = STRBUF_INIT;\n+\tint N = 50;\n+\tstruct reftable_reader rd = { NULL };\n+\tstruct reftable_block_source source = { NULL };\n+\tint err;\n+\tint i;\n+\tstruct reftable_log_record log = { NULL };\n+\tstruct reftable_iterator it = { NULL };\n+\n+\twrite_table(&names, &buf, N, 256, SHA1_ID);\n+\n+\tblock_source_from_strbuf(&source, &buf);\n+\n+\terr = init_reader(&rd, &source, \"file.ref\");\n+\tassert_err(err);\n+\n+\terr = reftable_reader_seek_ref(&rd, &it, names);\n+\tassert_err(err);\n+\n+\terr = reftable_iterator_next_log(&it, &log);\n+\tassert(err == REFTABLE_API_ERROR);\n+\n+\tstrbuf_release(&buf);\n+\tfor (i = 0; i < N; i++) {\n+\t\treftable_free(names[i]);\n+\t}\n+\treftable_iterator_destroy(&it);\n+\treftable_free(names);\n+\tstrbuf_release(&buf);\n+}\n+\n+static void test_table_read_write_seek(int index, int hash_id)\n+{\n+\tchar **names;\n+\tstruct strbuf buf = STRBUF_INIT;\n+\tint N = 50;\n+\tstruct reftable_reader rd = { NULL };\n+\tstruct reftable_block_source source = { NULL };\n+\tint err;\n+\tint i = 0;\n+\n+\tstruct reftable_iterator it = { NULL };\n+\tstruct strbuf pastLast = STRBUF_INIT;\n+\tstruct reftable_ref_record ref = { NULL };\n+\n+\twrite_table(&names, &buf, N, 256, hash_id);\n+\n+\tblock_source_from_strbuf(&source, &buf);\n+\n+\terr = init_reader(&rd, &source, \"file.ref\");\n+\tassert_err(err);\n+\n+\tif (!index) {\n+\t\trd.ref_offsets.index_offset = 0;\n+\t} else {\n+\t\tassert(rd.ref_offsets.index_offset > 0);\n+\t}\n+\n+\tfor (i = 1; i < N; i++) {\n+\t\tint err = reftable_reader_seek_ref(&rd, &it, names[i]);\n+\t\tassert_err(err);\n+\t\terr = reftable_iterator_next_ref(&it, &ref);\n+\t\tassert_err(err);\n+\t\tassert(0 == strcmp(names[i], ref.refname));\n+\t\tassert(i == ref.value);\n+\n+\t\treftable_ref_record_clear(&ref);\n+\t\treftable_iterator_destroy(&it);\n+\t}\n+\n+\n+\terr = reftable_reader_seek_ref(&rd, &it, pastLast.buf);\n+\tif (err == 0) {\n+\t\tstruct reftable_ref_record ref = { NULL };\n+\t\tint err = reftable_iterator_next_ref(&it, &ref);\n+\t\tassert(err > 0);\n+\t} else {\n+\t\tassert(err > 0);\n+\t}\n+\n+\tstrbuf_release(&pastLast);\n+\treftable_iterator_destroy(&it);\n+\n+\tstrbuf_release(&buf);\n+\tfor (i = 0; i < N; i++) {\n+\t\treftable_free(names[i]);\n+\t}\n+\treftable_free(names);\n+}\n+\n+{\n+}\n+\n+{\n+}\n+\n+{\n+}\n+\n+static void test_table_refs_for(int indexed)\n+{\n+\tint N = 50;\n+\tchar **want_names = reftable_calloc(sizeof(char *) * (N + 1));\n+\tint want_names_len = 0;\n+\tuint8_t want_hash[SHA1_SIZE];\n+\n+\tstruct reftable_write_options opts = {\n+\t\t.block_size = 256,\n+\t};\n+\tstruct reftable_ref_record ref = { NULL };\n+\tint i = 0;\n+\tint n;\n+\tint err;\n+\tstruct reftable_block_source source = { NULL };\n+\n+\tstruct strbuf buf = STRBUF_INIT;\n+\tstruct reftable_writer *w =\n+\n+\tstruct reftable_iterator it = { NULL };\n+\tint j;\n+\n+\tset_test_hash(want_hash, 4);\n+\n+\tfor (i = 0; i < N; i++) {\n+\t\tuint8_t hash[SHA1_SIZE];\n+\t\tchar fill = { 0 };\n+\t\tchar name;\n+\t\tuint8_t hash1[SHA1_SIZE];\n+\t\tuint8_t hash2[SHA1_SIZE];\n+\t\tstruct reftable_ref_record ref = { NULL };\n+\n+\t\tmemset(hash, i, sizeof(hash));\n+\t\tmemset(fill, 'x', 50);\n+\t\t/* Put the variable part in the start */\n+\t\tsnprintf(name, sizeof(name), \"br%02d%s\", i, fill);\n+\t\tname = 0;\n+\t\tref.refname = name;\n+\n+\t\tset_test_hash(hash1, i / 4);\n+\t\tset_test_hash(hash2, 3 + i / 4);\n+\t\tref.value = hash1;\n+\t\tref.target_value = hash2;\n+\n+\t\t/* 80 bytes / entry, so 3 entries per block. Yields 17\n+\t\t */\n+\t\t/* blocks. */\n+\t\tassert(n == 0);\n+\n+\t\tif (!memcmp(hash1, want_hash, SHA1_SIZE) ||\n+\t\t !memcmp(hash2, want_hash, SHA1_SIZE)) {\n+\t\t\twant_names[want_names_len++] = xstrdup(name);\n+\t\t}\n+\t}\n+\n+\tn = reftable_writer_close(w);\n+\tassert(n == 0);\n+\n+\treftable_writer_free(w);\n+\tw = NULL;\n+\n+\tblock_source_from_strbuf(&source, &buf);\n+\n+\terr = init_reader(&rd, &source, \"file.ref\");\n+\tassert_err(err);\n+\tif (!indexed) {\n+\t\trd.obj_offsets.is_present = 0;\n+\t}\n+\n+\terr = reftable_reader_seek_ref(&rd, &it, \"\");\n+\tassert_err(err);\n+\treftable_iterator_destroy(&it);\n+\n+\terr = reftable_reader_refs_for(&rd, &it, want_hash);\n+\tassert_err(err);\n+\n+\tj = 0;\n+\twhile (1) {\n+\t\tint err = reftable_iterator_next_ref(&it, &ref);\n+\t\tassert(err >= 0);\n+\t\tif (err > 0) {\n+\t\t\tbreak;\n+\t\t}\n+\n+\t\tassert(j < want_names_len);\n+\t\tassert(0 == strcmp(ref.refname, want_names[j]));\n+\t\tj++;\n+\t\treftable_ref_record_clear(&ref);\n+\t}\n+\tassert(j == want_names_len);\n+\n+\tstrbuf_release(&buf);\n+\tfree_names(want_names);\n+\treftable_iterator_destroy(&it);\n+}\n+\n+static void test_table_refs_for_no_index(void)\n+{\n+\ttest_table_refs_for(0);\n+}\n+\n+static void test_table_refs_for_obj_index(void)\n+{\n+\ttest_table_refs_for(1);\n+}\n+\n+static void test_table_empty(void)\n+{\n+\tstruct reftable_write_options opts = { 0 };\n+\tstruct strbuf buf = STRBUF_INIT;\n+\tstruct reftable_writer *w =\n+\tstruct reftable_block_source source = { NULL };\n+\tstruct reftable_reader *rd = NULL;\n+\tstruct reftable_ref_record rec = { NULL };\n+\tstruct reftable_iterator it = { NULL };\n+\tint err;\n+\n+\treftable_writer_set_limits(w, 1, 1);\n+\n+\terr = reftable_writer_close(w);\n+\tassert(err == REFTABLE_EMPTY_TABLE_ERROR);\n+\treftable_writer_free(w);\n+\n+\tassert(buf.len == header_size(1) + footer_size(1));\n+\n+\tblock_source_from_strbuf(&source, &buf);\n+\n+\terr = reftable_new_reader(&rd, &source, \"filename\");\n+\tassert_err(err);\n+\n+\terr = reftable_reader_seek_ref(rd, &it, \"\");\n+\tassert_err(err);\n+\n+\terr = reftable_iterator_next_ref(&it, &rec);\n+\tassert(err > 0);\n+\n+\treftable_iterator_destroy(&it);\n+\tstrbuf_release(&buf);\n+}\n+\n+int reftable_test_main(int argc, const char *argv[])\n+{\n+\t\t &test_table_write_small_table);\n+\t\t &test_table_refs_for_no_index);\n+\t\t &test_table_refs_for_obj_index);\n+\treturn test_main(argc, argv);\n+}\ndiff --git a/t/helper/test-reftable.c b/t/helper/test-reftable.c\nindex 9c4e0f42dc..2273fdfe39 100644\n--- a/t/helper/test-reftable.c\n+++ b/t/helper/test-reftable.c\n@@ -5,6 +5,7 @@ int cmd__reftable(int argc, const char **argv)\n{\nblock_test_main(argc, argv);\nrecord_test_main(argc, argv);\n+\treftable_test_main(argc, argv);\nstrbuf_test_main(argc, argv);\ntree_test_main(argc, argv);\nreturn 0;\n--\n\n• ```* [PATCH v2 12/13] reftable: rest of library\n2020-10-01 16:10 ` [PATCH v2 00/13] reftable library Han-Wen Nienhuys via GitGitGadget\n` (10 preceding siblings ...)\n2020-10-01 16:11 ` [PATCH v2 11/13] reftable: file level tests Han-Wen Nienhuys via GitGitGadget\n@ 2020-10-01 16:11 ` Han-Wen Nienhuys via GitGitGadget\n2020-10-02 13:57 ` Johannes Schindelin\n2020-10-01 16:11 ` [PATCH v2 13/13] reftable: \"test-tool dump-reftable\" command Han-Wen Nienhuys via GitGitGadget\n2020-11-26 19:42 ` [PATCH v3 00/16] reftable library Han-Wen Nienhuys via GitGitGadget\nFrom: Han-Wen Nienhuys via GitGitGadget @ 2020-10-01 16:11 UTC (permalink / raw)\nTo: git; +Cc: Han-Wen Nienhuys, Jeff King, Han-Wen Nienhuys, Han-Wen Nienhuys\n\nThis will be further split up once preceding commits have passed review.\n\n---\nMakefile | 8 +-\nreftable/VERSION | 1 +\nreftable/dump.c | 212 +++++++\nreftable/merged.c | 358 +++++++++++\nreftable/merged.h | 36 ++\nreftable/merged_test.c | 331 ++++++++++\nreftable/pq.c | 115 ++++\nreftable/pq.h | 32 +\nreftable/refname.c | 209 +++++++\nreftable/refname.h | 28 +\nreftable/refname_test.c | 100 +++\nreftable/reftable.c | 4 +-\nreftable/stack.c | 1240 ++++++++++++++++++++++++++++++++++++++\nreftable/stack.h | 40 ++\nreftable/stack_test.c | 788 ++++++++++++++++++++++++\nreftable/update.sh | 22 +\nt/helper/test-reftable.c | 3 +\n17 files changed, 3524 insertions(+), 3 deletions(-)\ncreate mode 100644 reftable/VERSION\ncreate mode 100644 reftable/dump.c\ncreate mode 100644 reftable/merged.c\ncreate mode 100644 reftable/merged.h\ncreate mode 100644 reftable/merged_test.c\ncreate mode 100644 reftable/pq.c\ncreate mode 100644 reftable/pq.h\ncreate mode 100644 reftable/refname.c\ncreate mode 100644 reftable/refname.h\ncreate mode 100644 reftable/refname_test.c\ncreate mode 100644 reftable/stack.c\ncreate mode 100644 reftable/stack.h\ncreate mode 100644 reftable/stack_test.c\ncreate mode 100755 reftable/update.sh\n\ndiff --git a/Makefile b/Makefile\nindex 17d5fba0a0..05021f79a1 100644\n--- a/Makefile\n+++ b/Makefile\n@@ -2375,12 +2375,16 @@ XDIFF_OBJS += xdiff/xutils.o\nREFTABLE_OBJS += reftable/basics.o\nREFTABLE_OBJS += reftable/block.o\nREFTABLE_OBJS += reftable/blocksource.o\n-REFTABLE_OBJS += reftable/publicbasics.o\nREFTABLE_OBJS += reftable/compat.o\nREFTABLE_OBJS += reftable/iter.o\n+REFTABLE_OBJS += reftable/merged.o\n+REFTABLE_OBJS += reftable/pq.o\n+REFTABLE_OBJS += reftable/publicbasics.o\nREFTABLE_OBJS += reftable/record.o\n+REFTABLE_OBJS += reftable/refname.o\nREFTABLE_OBJS += reftable/reftable.o\n+REFTABLE_OBJS += reftable/stack.o\nREFTABLE_OBJS += reftable/strbuf.o\nREFTABLE_OBJS += reftable/tree.o\nREFTABLE_OBJS += reftable/writer.o\n@@ -2388,7 +2392,9 @@ REFTABLE_OBJS += reftable/zlib-compat.o\n\nREFTABLE_TEST_OBJS += reftable/block_test.o\nREFTABLE_TEST_OBJS += reftable/record_test.o\n+REFTABLE_TEST_OBJS += reftable/refname_test.o\nREFTABLE_TEST_OBJS += reftable/reftable_test.o\n+REFTABLE_TEST_OBJS += reftable/stack_test.o\nREFTABLE_TEST_OBJS += reftable/strbuf_test.o\nREFTABLE_TEST_OBJS += reftable/test_framework.o\nREFTABLE_TEST_OBJS += reftable/tree_test.o\ndiff --git a/reftable/VERSION b/reftable/VERSION\nnew file mode 100644\nindex 0000000000..cf8ae4958f\n--- /dev/null\n+++ b/reftable/VERSION\n@@ -0,0 +1 @@\n+7134eb9f8171a9759800f4187f9e6dde997335e7 C: NULL iso 0 for init\ndiff --git a/reftable/dump.c b/reftable/dump.c\nnew file mode 100644\nindex 0000000000..ed09f2e2f9\n--- /dev/null\n+++ b/reftable/dump.c\n@@ -0,0 +1,212 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include <stddef.h>\n+#include <stdio.h>\n+#include <stdlib.h>\n+#include <unistd.h>\n+#include <string.h>\n+\n+#include \"reftable.h\"\n+#include \"reftable-tests.h\"\n+\n+static uint32_t hash_id;\n+\n+static int dump_table(const char *tablename)\n+{\n+\tstruct reftable_block_source src = { NULL };\n+\tint err = reftable_block_source_from_file(&src, tablename);\n+\tstruct reftable_iterator it = { NULL };\n+\tstruct reftable_ref_record ref = { NULL };\n+\tstruct reftable_log_record log = { NULL };\n+\tstruct reftable_reader *r = NULL;\n+\n+\tif (err < 0)\n+\t\treturn err;\n+\n+\terr = reftable_new_reader(&r, &src, tablename);\n+\tif (err < 0)\n+\t\treturn err;\n+\n+\terr = reftable_reader_seek_ref(r, &it, \"\");\n+\tif (err < 0) {\n+\t\treturn err;\n+\t}\n+\n+\twhile (1) {\n+\t\terr = reftable_iterator_next_ref(&it, &ref);\n+\t\tif (err > 0) {\n+\t\t\tbreak;\n+\t\t}\n+\t\tif (err < 0) {\n+\t\t\treturn err;\n+\t\t}\n+\t\treftable_ref_record_print(&ref, hash_id);\n+\t}\n+\treftable_iterator_destroy(&it);\n+\treftable_ref_record_clear(&ref);\n+\n+\terr = reftable_reader_seek_log(r, &it, \"\");\n+\tif (err < 0) {\n+\t\treturn err;\n+\t}\n+\twhile (1) {\n+\t\terr = reftable_iterator_next_log(&it, &log);\n+\t\tif (err > 0) {\n+\t\t\tbreak;\n+\t\t}\n+\t\tif (err < 0) {\n+\t\t\treturn err;\n+\t\t}\n+\t\treftable_log_record_print(&log, hash_id);\n+\t}\n+\treftable_iterator_destroy(&it);\n+\treftable_log_record_clear(&log);\n+\n+\treturn 0;\n+}\n+\n+static int compact_stack(const char *stackdir)\n+{\n+\tstruct reftable_stack *stack = NULL;\n+\tstruct reftable_write_options cfg = {};\n+\n+\tint err = reftable_new_stack(&stack, stackdir, cfg);\n+\tif (err < 0)\n+\t\tgoto done;\n+\n+\terr = reftable_stack_compact_all(stack, NULL);\n+\tif (err < 0)\n+\t\tgoto done;\n+done:\n+\tif (stack != NULL) {\n+\t\treftable_stack_destroy(stack);\n+\t}\n+\treturn err;\n+}\n+\n+static int dump_stack(const char *stackdir)\n+{\n+\tstruct reftable_stack *stack = NULL;\n+\tstruct reftable_write_options cfg = {};\n+\tstruct reftable_iterator it = { NULL };\n+\tstruct reftable_ref_record ref = { NULL };\n+\tstruct reftable_log_record log = { NULL };\n+\tstruct reftable_merged_table *merged = NULL;\n+\n+\tint err = reftable_new_stack(&stack, stackdir, cfg);\n+\tif (err < 0)\n+\t\treturn err;\n+\n+\tmerged = reftable_stack_merged_table(stack);\n+\n+\terr = reftable_merged_table_seek_ref(merged, &it, \"\");\n+\tif (err < 0) {\n+\t\treturn err;\n+\t}\n+\n+\twhile (1) {\n+\t\terr = reftable_iterator_next_ref(&it, &ref);\n+\t\tif (err > 0) {\n+\t\t\tbreak;\n+\t\t}\n+\t\tif (err < 0) {\n+\t\t\treturn err;\n+\t\t}\n+\t\treftable_ref_record_print(&ref, hash_id);\n+\t}\n+\treftable_iterator_destroy(&it);\n+\treftable_ref_record_clear(&ref);\n+\n+\terr = reftable_merged_table_seek_log(merged, &it, \"\");\n+\tif (err < 0) {\n+\t\treturn err;\n+\t}\n+\twhile (1) {\n+\t\terr = reftable_iterator_next_log(&it, &log);\n+\t\tif (err > 0) {\n+\t\t\tbreak;\n+\t\t}\n+\t\tif (err < 0) {\n+\t\t\treturn err;\n+\t\t}\n+\t\treftable_log_record_print(&log, hash_id);\n+\t}\n+\treftable_iterator_destroy(&it);\n+\treftable_log_record_clear(&log);\n+\n+\treftable_stack_destroy(stack);\n+\treturn 0;\n+}\n+\n+static void print_help(void)\n+{\n+\tprintf(\"usage: dump [-cst] arg\\n\\n\"\n+\t \"options: \\n\"\n+\t \" -c compact\\n\"\n+\t \" -t dump table\\n\"\n+\t \" -s dump stack\\n\"\n+\t \" -h this help\\n\"\n+\t \" -2 use SHA256\\n\"\n+\t \"\\n\");\n+}\n+\n+int reftable_dump_main(int argc, char *const *argv)\n+{\n+\tint err = 0;\n+\tint opt;\n+\tint opt_dump_table = 0;\n+\tint opt_dump_stack = 0;\n+\tint opt_compact = 0;\n+\tconst char *arg = NULL;\n+\twhile ((opt = getopt(argc, argv, \"2chts\")) != -1) {\n+\t\tswitch (opt) {\n+\t\tcase '2':\n+\t\t\thash_id = 0x73323536;\n+\t\t\tbreak;\n+\t\tcase 't':\n+\t\t\topt_dump_table = 1;\n+\t\t\tbreak;\n+\t\tcase 's':\n+\t\t\topt_dump_stack = 1;\n+\t\t\tbreak;\n+\t\tcase 'c':\n+\t\t\topt_compact = 1;\n+\t\t\tbreak;\n+\t\tcase '?':\n+\t\tcase 'h':\n+\t\t\tprint_help();\n+\t\t\treturn 2;\n+\t\t\tbreak;\n+\t\t}\n+\t}\n+\n+\tif (argv[optind] == NULL) {\n+\t\tfprintf(stderr, \"need argument\\n\");\n+\t\tprint_help();\n+\t\treturn 2;\n+\t}\n+\n+\targ = argv[optind];\n+\n+\tif (opt_dump_table) {\n+\t\terr = dump_table(arg);\n+\t} else if (opt_dump_stack) {\n+\t\terr = dump_stack(arg);\n+\t} else if (opt_compact) {\n+\t\terr = compact_stack(arg);\n+\t}\n+\n+\tif (err < 0) {\n+\t\tfprintf(stderr, \"%s: %s: %s\\n\", argv, arg,\n+\t\t\treftable_error_str(err));\n+\t\treturn 1;\n+\t}\n+\treturn 0;\n+}\ndiff --git a/reftable/merged.c b/reftable/merged.c\nnew file mode 100644\nindex 0000000000..bfa89cfaee\n--- /dev/null\n+++ b/reftable/merged.c\n@@ -0,0 +1,358 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"merged.h\"\n+\n+#include \"constants.h\"\n+#include \"iter.h\"\n+#include \"pq.h\"\n+#include \"record.h\"\n+#include \"reftable.h\"\n+#include \"system.h\"\n+\n+static int merged_iter_init(struct merged_iter *mi)\n+{\n+\tint i = 0;\n+\tfor (i = 0; i < mi->stack_len; i++) {\n+\t\tstruct reftable_record rec = reftable_new_record(mi->typ);\n+\t\tint err = iterator_next(&mi->stack[i], &rec);\n+\t\tif (err < 0) {\n+\t\t\treturn err;\n+\t\t}\n+\n+\t\tif (err > 0) {\n+\t\t\treftable_iterator_destroy(&mi->stack[i]);\n+\t\t\treftable_record_destroy(&rec);\n+\t\t} else {\n+\t\t\tstruct pq_entry e = {\n+\t\t\t\t.rec = rec,\n+\t\t\t\t.index = i,\n+\t\t\t};\n+\t\t}\n+\t}\n+\n+\treturn 0;\n+}\n+\n+static void merged_iter_close(void *p)\n+{\n+\tstruct merged_iter *mi = (struct merged_iter *)p;\n+\tint i = 0;\n+\tmerged_iter_pqueue_clear(&mi->pq);\n+\tfor (i = 0; i < mi->stack_len; i++) {\n+\t\treftable_iterator_destroy(&mi->stack[i]);\n+\t}\n+\treftable_free(mi->stack);\n+}\n+\n+\t\t\t\t\t size_t idx)\n+{\n+\tstruct reftable_record rec = reftable_new_record(mi->typ);\n+\tstruct pq_entry e = {\n+\t\t.rec = rec,\n+\t\t.index = idx,\n+\t};\n+\tint err = iterator_next(&mi->stack[idx], &rec);\n+\tif (err < 0)\n+\t\treturn err;\n+\n+\tif (err > 0) {\n+\t\treftable_iterator_destroy(&mi->stack[idx]);\n+\t\treftable_record_destroy(&rec);\n+\t\treturn 0;\n+\t}\n+\n+\treturn 0;\n+}\n+\n+static int merged_iter_advance_subiter(struct merged_iter *mi, size_t idx)\n+{\n+\tif (iterator_is_null(&mi->stack[idx]))\n+\t\treturn 0;\n+}\n+\n+static int merged_iter_next_entry(struct merged_iter *mi,\n+\t\t\t\t struct reftable_record *rec)\n+{\n+\tstruct strbuf entry_key = STRBUF_INIT;\n+\tstruct pq_entry entry = { 0 };\n+\tint err = 0;\n+\n+\tif (merged_iter_pqueue_is_empty(mi->pq))\n+\t\treturn 1;\n+\n+\tentry = merged_iter_pqueue_remove(&mi->pq);\n+\tif (err < 0)\n+\t\treturn err;\n+\n+\t/*\n+\t One can also use reftable as datacenter-local storage, where the ref\n+\t database is maintained in globally consistent database (eg.\n+\t CockroachDB or Spanner). In this scenario, replication delays together\n+\t with compaction may cause newer tables to contain older entries. In\n+\t such a deployment, the loop below must be changed to collect all\n+\t entries for the same key, and return new the newest one.\n+\t*/\n+\treftable_record_key(&entry.rec, &entry_key);\n+\twhile (!merged_iter_pqueue_is_empty(mi->pq)) {\n+\t\tstruct pq_entry top = merged_iter_pqueue_top(mi->pq);\n+\t\tstruct strbuf k = STRBUF_INIT;\n+\t\tint err = 0, cmp = 0;\n+\n+\t\treftable_record_key(&top.rec, &k);\n+\n+\t\tcmp = strbuf_cmp(&k, &entry_key);\n+\t\tstrbuf_release(&k);\n+\n+\t\tif (cmp > 0) {\n+\t\t\tbreak;\n+\t\t}\n+\n+\t\tmerged_iter_pqueue_remove(&mi->pq);\n+\t\tif (err < 0) {\n+\t\t\treturn err;\n+\t\t}\n+\t\treftable_record_destroy(&top.rec);\n+\t}\n+\n+\treftable_record_copy_from(rec, &entry.rec, hash_size(mi->hash_id));\n+\treftable_record_destroy(&entry.rec);\n+\tstrbuf_release(&entry_key);\n+\treturn 0;\n+}\n+\n+static int merged_iter_next(struct merged_iter *mi, struct reftable_record *rec)\n+{\n+\twhile (1) {\n+\t\tint err = merged_iter_next_entry(mi, rec);\n+\t\tif (err == 0 && mi->suppress_deletions &&\n+\t\t reftable_record_is_deletion(rec)) {\n+\t\t\tcontinue;\n+\t\t}\n+\n+\t\treturn err;\n+\t}\n+}\n+\n+static int merged_iter_next_void(void *p, struct reftable_record *rec)\n+{\n+\tstruct merged_iter *mi = (struct merged_iter *)p;\n+\tif (merged_iter_pqueue_is_empty(mi->pq))\n+\t\treturn 1;\n+\n+\treturn merged_iter_next(mi, rec);\n+}\n+\n+static struct reftable_iterator_vtable merged_iter_vtable = {\n+\t.next = &merged_iter_next_void,\n+\t.close = &merged_iter_close,\n+};\n+\n+static void iterator_from_merged_iter(struct reftable_iterator *it,\n+\t\t\t\t struct merged_iter *mi)\n+{\n+\tassert(it->ops == NULL);\n+\tit->iter_arg = mi;\n+\tit->ops = &merged_iter_vtable;\n+}\n+\n+int reftable_new_merged_table(struct reftable_merged_table **dest,\n+\t\t\t struct reftable_table *stack, int n,\n+\t\t\t uint32_t hash_id)\n+{\n+\tstruct reftable_merged_table *m = NULL;\n+\tuint64_t last_max = 0;\n+\tuint64_t first_min = 0;\n+\tint i = 0;\n+\tfor (i = 0; i < n; i++) {\n+\t\tuint64_t min = reftable_table_min_update_index(&stack[i]);\n+\t\tuint64_t max = reftable_table_max_update_index(&stack[i]);\n+\n+\t\tif (reftable_table_hash_id(&stack[i]) != hash_id) {\n+\t\t\treturn REFTABLE_FORMAT_ERROR;\n+\t\t}\n+\t\tif (i == 0 || min < first_min) {\n+\t\t\tfirst_min = min;\n+\t\t}\n+\t\tif (i == 0 || max > last_max) {\n+\t\t\tlast_max = max;\n+\t\t}\n+\t}\n+\n+\tm = (struct reftable_merged_table *)reftable_calloc(\n+\t\tsizeof(struct reftable_merged_table));\n+\tm->stack = stack;\n+\tm->stack_len = n;\n+\tm->min = first_min;\n+\tm->max = last_max;\n+\tm->hash_id = hash_id;\n+\t*dest = m;\n+\treturn 0;\n+}\n+\n+/* clears the list of subtable, without affecting the readers themselves. */\n+void merged_table_clear(struct reftable_merged_table *mt)\n+{\n+\tFREE_AND_NULL(mt->stack);\n+\tmt->stack_len = 0;\n+}\n+\n+void reftable_merged_table_free(struct reftable_merged_table *mt)\n+{\n+\tif (mt == NULL) {\n+\t\treturn;\n+\t}\n+\tmerged_table_clear(mt);\n+\treftable_free(mt);\n+}\n+\n+uint64_t\n+reftable_merged_table_max_update_index(struct reftable_merged_table *mt)\n+{\n+\treturn mt->max;\n+}\n+\n+uint64_t\n+reftable_merged_table_min_update_index(struct reftable_merged_table *mt)\n+{\n+\treturn mt->min;\n+}\n+\n+static int merged_table_seek_record(struct reftable_merged_table *mt,\n+\t\t\t\t struct reftable_iterator *it,\n+\t\t\t\t struct reftable_record *rec)\n+{\n+\tstruct reftable_iterator *iters = reftable_calloc(\n+\t\tsizeof(struct reftable_iterator) * mt->stack_len);\n+\tstruct merged_iter merged = {\n+\t\t.stack = iters,\n+\t\t.typ = reftable_record_type(rec),\n+\t\t.hash_id = mt->hash_id,\n+\t\t.suppress_deletions = mt->suppress_deletions,\n+\t};\n+\tint n = 0;\n+\tint err = 0;\n+\tint i = 0;\n+\tfor (i = 0; i < mt->stack_len && err == 0; i++) {\n+\t\tint e = reftable_table_seek_record(&mt->stack[i], &iters[n],\n+\t\t\t\t\t\t rec);\n+\t\tif (e < 0) {\n+\t\t\terr = e;\n+\t\t}\n+\t\tif (e == 0) {\n+\t\t\tn++;\n+\t\t}\n+\t}\n+\tif (err < 0) {\n+\t\tint i = 0;\n+\t\tfor (i = 0; i < n; i++) {\n+\t\t\treftable_iterator_destroy(&iters[i]);\n+\t\t}\n+\t\treftable_free(iters);\n+\t\treturn err;\n+\t}\n+\n+\tmerged.stack_len = n;\n+\terr = merged_iter_init(&merged);\n+\tif (err < 0) {\n+\t\tmerged_iter_close(&merged);\n+\t\treturn err;\n+\t} else {\n+\t\tstruct merged_iter *p =\n+\t\t\treftable_malloc(sizeof(struct merged_iter));\n+\t\t*p = merged;\n+\t\titerator_from_merged_iter(it, p);\n+\t}\n+\treturn 0;\n+}\n+\n+int reftable_merged_table_seek_ref(struct reftable_merged_table *mt,\n+\t\t\t\t struct reftable_iterator *it,\n+\t\t\t\t const char *name)\n+{\n+\tstruct reftable_ref_record ref = {\n+\t\t.refname = (char *)name,\n+\t};\n+\tstruct reftable_record rec = { NULL };\n+\treftable_record_from_ref(&rec, &ref);\n+\treturn merged_table_seek_record(mt, it, &rec);\n+}\n+\n+int reftable_merged_table_seek_log_at(struct reftable_merged_table *mt,\n+\t\t\t\t struct reftable_iterator *it,\n+\t\t\t\t const char *name, uint64_t update_index)\n+{\n+\tstruct reftable_log_record log = {\n+\t\t.refname = (char *)name,\n+\t\t.update_index = update_index,\n+\t};\n+\tstruct reftable_record rec = { NULL };\n+\treftable_record_from_log(&rec, &log);\n+\treturn merged_table_seek_record(mt, it, &rec);\n+}\n+\n+int reftable_merged_table_seek_log(struct reftable_merged_table *mt,\n+\t\t\t\t struct reftable_iterator *it,\n+\t\t\t\t const char *name)\n+{\n+\tuint64_t max = ~((uint64_t)0);\n+\treturn reftable_merged_table_seek_log_at(mt, it, name, max);\n+}\n+\n+uint32_t reftable_merged_table_hash_id(struct reftable_merged_table *mt)\n+{\n+\treturn mt->hash_id;\n+}\n+\n+static int reftable_merged_table_seek_void(void *tab,\n+\t\t\t\t\t struct reftable_iterator *it,\n+\t\t\t\t\t struct reftable_record *rec)\n+{\n+\treturn merged_table_seek_record((struct reftable_merged_table *)tab, it,\n+\t\t\t\t\trec);\n+}\n+\n+static uint32_t reftable_merged_table_hash_id_void(void *tab)\n+{\n+\treturn reftable_merged_table_hash_id(\n+\t\t(struct reftable_merged_table *)tab);\n+}\n+\n+static uint64_t reftable_merged_table_min_update_index_void(void *tab)\n+{\n+\treturn reftable_merged_table_min_update_index(\n+\t\t(struct reftable_merged_table *)tab);\n+}\n+\n+static uint64_t reftable_merged_table_max_update_index_void(void *tab)\n+{\n+\treturn reftable_merged_table_max_update_index(\n+\t\t(struct reftable_merged_table *)tab);\n+}\n+\n+static struct reftable_table_vtable merged_table_vtable = {\n+\t.seek_record = reftable_merged_table_seek_void,\n+\t.hash_id = reftable_merged_table_hash_id_void,\n+\t.min_update_index = reftable_merged_table_min_update_index_void,\n+\t.max_update_index = reftable_merged_table_max_update_index_void,\n+};\n+\n+void reftable_table_from_merged_table(struct reftable_table *tab,\n+\t\t\t\t struct reftable_merged_table *merged)\n+{\n+\tassert(tab->ops == NULL);\n+\ttab->ops = &merged_table_vtable;\n+\ttab->table_arg = merged;\n+}\ndiff --git a/reftable/merged.h b/reftable/merged.h\nnew file mode 100644\nindex 0000000000..76c29928c3\n--- /dev/null\n+++ b/reftable/merged.h\n@@ -0,0 +1,36 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#ifndef MERGED_H\n+#define MERGED_H\n+\n+#include \"pq.h\"\n+#include \"reftable.h\"\n+\n+struct reftable_merged_table {\n+\tstruct reftable_table *stack;\n+\tsize_t stack_len;\n+\tuint32_t hash_id;\n+\tint suppress_deletions;\n+\n+\tuint64_t min;\n+\tuint64_t max;\n+};\n+\n+struct merged_iter {\n+\tstruct reftable_iterator *stack;\n+\tuint32_t hash_id;\n+\tsize_t stack_len;\n+\tuint8_t typ;\n+\tint suppress_deletions;\n+\tstruct merged_iter_pqueue pq;\n+};\n+\n+void merged_table_clear(struct reftable_merged_table *mt);\n+\n+#endif\ndiff --git a/reftable/merged_test.c b/reftable/merged_test.c\nnew file mode 100644\nindex 0000000000..66c65a8ea4\n--- /dev/null\n+++ b/reftable/merged_test.c\n@@ -0,0 +1,331 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"merged.h\"\n+\n+#include \"system.h\"\n+\n+#include \"basics.h\"\n+#include \"blocksource.h\"\n+#include \"constants.h\"\n+#include \"pq.h\"\n+#include \"record.h\"\n+#include \"reftable.h\"\n+#include \"test_framework.h\"\n+#include \"reftable-tests.h\"\n+\n+static void test_pq(void)\n+{\n+\tchar *names = { NULL };\n+\tint N = ARRAY_SIZE(names) - 1;\n+\n+\tstruct merged_iter_pqueue pq = { NULL };\n+\tconst char *last = NULL;\n+\n+\tint i = 0;\n+\tfor (i = 0; i < N; i++) {\n+\t\tchar name;\n+\t\tsnprintf(name, sizeof(name), \"%02d\", i);\n+\t\tnames[i] = xstrdup(name);\n+\t}\n+\n+\ti = 1;\n+\tdo {\n+\t\tstruct reftable_record rec =\n+\t\t\treftable_new_record(BLOCK_TYPE_REF);\n+\t\tstruct pq_entry e = { 0 };\n+\n+\t\treftable_record_as_ref(&rec)->refname = names[i];\n+\t\te.rec = rec;\n+\t\tmerged_iter_pqueue_check(pq);\n+\t\ti = (i * 7) % N;\n+\t} while (i != 1);\n+\n+\twhile (!merged_iter_pqueue_is_empty(pq)) {\n+\t\tstruct pq_entry e = merged_iter_pqueue_remove(&pq);\n+\t\tstruct reftable_ref_record *ref =\n+\t\t\treftable_record_as_ref(&e.rec);\n+\n+\t\tmerged_iter_pqueue_check(pq);\n+\n+\t\tif (last != NULL) {\n+\t\t\tassert(strcmp(last, ref->refname) < 0);\n+\t\t}\n+\t\tlast = ref->refname;\n+\t\tref->refname = NULL;\n+\t\treftable_free(ref);\n+\t}\n+\n+\tfor (i = 0; i < N; i++) {\n+\t\treftable_free(names[i]);\n+\t}\n+\n+\tmerged_iter_pqueue_clear(&pq);\n+}\n+\n+static void write_test_table(struct strbuf *buf,\n+\t\t\t struct reftable_ref_record refs[], int n)\n+{\n+\tint min = 0xffffffff;\n+\tint max = 0;\n+\tint i = 0;\n+\tint err;\n+\n+\tstruct reftable_write_options opts = {\n+\t\t.block_size = 256,\n+\t};\n+\tstruct reftable_writer *w = NULL;\n+\tfor (i = 0; i < n; i++) {\n+\t\tuint64_t ui = refs[i].update_index;\n+\t\tif (ui > max) {\n+\t\t\tmax = ui;\n+\t\t}\n+\t\tif (ui < min) {\n+\t\t\tmin = ui;\n+\t\t}\n+\t}\n+\n+\tw = reftable_new_writer(&strbuf_add_void, buf, &opts);\n+\treftable_writer_set_limits(w, min, max);\n+\n+\tfor (i = 0; i < n; i++) {\n+\t\tuint64_t before = refs[i].update_index;\n+\t\tint n = reftable_writer_add_ref(w, &refs[i]);\n+\t\tassert(n == 0);\n+\t\tassert(before == refs[i].update_index);\n+\t}\n+\n+\terr = reftable_writer_close(w);\n+\tassert_err(err);\n+\n+\treftable_writer_free(w);\n+}\n+\n+static struct reftable_merged_table *\n+merged_table_from_records(struct reftable_ref_record **refs,\n+\t\t\t struct reftable_block_source **source,\n+\t\t\t struct strbuf *buf, int n)\n+{\n+\tint i = 0;\n+\tstruct reftable_merged_table *mt = NULL;\n+\tint err;\n+\tstruct reftable_table *tabs =\n+\t\treftable_calloc(n * sizeof(struct reftable_table));\n+\t*source = reftable_calloc(n * sizeof(**source));\n+\tfor (i = 0; i < n; i++) {\n+\t\twrite_test_table(&buf[i], refs[i], sizes[i]);\n+\t\tblock_source_from_strbuf(&(*source)[i], &buf[i]);\n+\n+\t\t\t\t\t \"name\");\n+\t\tassert_err(err);\n+\t}\n+\n+\terr = reftable_new_merged_table(&mt, tabs, n, SHA1_ID);\n+\tassert_err(err);\n+\treturn mt;\n+}\n+\n+{\n+\tint i = 0;\n+\tfor (; i < n; i++)\n+}\n+\n+static void test_merged_between(void)\n+{\n+\tuint8_t hash1[SHA1_SIZE] = { 1, 2, 3, 0 };\n+\n+\tstruct reftable_ref_record r1[] = { {\n+\t\t.refname = \"b\",\n+\t\t.update_index = 1,\n+\t\t.value = hash1,\n+\t} };\n+\tstruct reftable_ref_record r2[] = { {\n+\t\t.refname = \"a\",\n+\t\t.update_index = 2,\n+\t} };\n+\n+\tstruct reftable_ref_record *refs[] = { r1, r2 };\n+\tint sizes[] = { 1, 1 };\n+\tstruct strbuf bufs = { STRBUF_INIT, STRBUF_INIT };\n+\tstruct reftable_block_source *bs = NULL;\n+\tstruct reftable_merged_table *mt =\n+\t\tmerged_table_from_records(refs, &bs, &readers, sizes, bufs, 2);\n+\tint i;\n+\tstruct reftable_ref_record ref = { NULL };\n+\tstruct reftable_iterator it = { NULL };\n+\tint err = reftable_merged_table_seek_ref(mt, &it, \"a\");\n+\tassert_err(err);\n+\n+\terr = reftable_iterator_next_ref(&it, &ref);\n+\tassert_err(err);\n+\tassert(ref.update_index == 2);\n+\treftable_ref_record_clear(&ref);\n+\treftable_iterator_destroy(&it);\n+\treftable_merged_table_free(mt);\n+\tfor (i = 0; i < ARRAY_SIZE(bufs); i++) {\n+\t\tstrbuf_release(&bufs[i]);\n+\t}\n+\treftable_free(bs);\n+}\n+\n+static void test_merged(void)\n+{\n+\tuint8_t hash1[SHA1_SIZE] = { 1 };\n+\tuint8_t hash2[SHA1_SIZE] = { 2 };\n+\tstruct reftable_ref_record r1[] = { {\n+\t\t\t\t\t\t .refname = \"a\",\n+\t\t\t\t\t\t .update_index = 1,\n+\t\t\t\t\t\t .value = hash1,\n+\t\t\t\t\t },\n+\t\t\t\t\t {\n+\t\t\t\t\t\t .refname = \"b\",\n+\t\t\t\t\t\t .update_index = 1,\n+\t\t\t\t\t\t .value = hash1,\n+\t\t\t\t\t },\n+\t\t\t\t\t {\n+\t\t\t\t\t\t .refname = \"c\",\n+\t\t\t\t\t\t .update_index = 1,\n+\t\t\t\t\t\t .value = hash1,\n+\t\t\t\t\t } };\n+\tstruct reftable_ref_record r2[] = { {\n+\t\t.refname = \"a\",\n+\t\t.update_index = 2,\n+\t} };\n+\tstruct reftable_ref_record r3[] = {\n+\t\t{\n+\t\t\t.refname = \"c\",\n+\t\t\t.update_index = 3,\n+\t\t\t.value = hash2,\n+\t\t},\n+\t\t{\n+\t\t\t.refname = \"d\",\n+\t\t\t.update_index = 3,\n+\t\t\t.value = hash1,\n+\t\t},\n+\t};\n+\n+\tstruct reftable_ref_record want[] = {\n+\t\tr2,\n+\t\tr1,\n+\t\tr3,\n+\t\tr3,\n+\t};\n+\n+\tstruct reftable_ref_record *refs[] = { r1, r2, r3 };\n+\tint sizes = { 3, 1, 2 };\n+\tstruct strbuf bufs = { STRBUF_INIT, STRBUF_INIT, STRBUF_INIT };\n+\tstruct reftable_block_source *bs = NULL;\n+\tstruct reftable_merged_table *mt =\n+\t\tmerged_table_from_records(refs, &bs, &readers, sizes, bufs, 3);\n+\n+\tstruct reftable_iterator it = { NULL };\n+\tint err = reftable_merged_table_seek_ref(mt, &it, \"a\");\n+\tstruct reftable_ref_record *out = NULL;\n+\tsize_t len = 0;\n+\tsize_t cap = 0;\n+\tint i = 0;\n+\n+\tassert_err(err);\n+\twhile (len < 100) { /* cap loops/recursion. */\n+\t\tstruct reftable_ref_record ref = { NULL };\n+\t\tint err = reftable_iterator_next_ref(&it, &ref);\n+\t\tif (err > 0) {\n+\t\t\tbreak;\n+\t\t}\n+\t\tif (len == cap) {\n+\t\t\tcap = 2 * cap + 1;\n+\t\t\tout = reftable_realloc(\n+\t\t\t\tout, sizeof(struct reftable_ref_record) * cap);\n+\t\t}\n+\t\tout[len++] = ref;\n+\t}\n+\treftable_iterator_destroy(&it);\n+\n+\tassert(ARRAY_SIZE(want) == len);\n+\tfor (i = 0; i < len; i++) {\n+\t\tassert(reftable_ref_record_equal(&want[i], &out[i], SHA1_SIZE));\n+\t}\n+\tfor (i = 0; i < len; i++) {\n+\t\treftable_ref_record_clear(&out[i]);\n+\t}\n+\treftable_free(out);\n+\n+\tfor (i = 0; i < 3; i++) {\n+\t\tstrbuf_release(&bufs[i]);\n+\t}\n+\treftable_merged_table_free(mt);\n+\treftable_free(bs);\n+}\n+\n+static void test_default_write_opts(void)\n+{\n+\tstruct reftable_write_options opts = { 0 };\n+\tstruct strbuf buf = STRBUF_INIT;\n+\tstruct reftable_writer *w =\n+\n+\tstruct reftable_ref_record rec = {\n+\t\t.refname = \"master\",\n+\t\t.update_index = 1,\n+\t};\n+\tint err;\n+\tstruct reftable_block_source source = { NULL };\n+\tstruct reftable_table *tab = reftable_calloc(sizeof(*tab) * 1);\n+\tuint32_t hash_id;\n+\tstruct reftable_reader *rd = NULL;\n+\tstruct reftable_merged_table *merged = NULL;\n+\n+\treftable_writer_set_limits(w, 1, 1);\n+\n+\tassert_err(err);\n+\n+\terr = reftable_writer_close(w);\n+\tassert_err(err);\n+\treftable_writer_free(w);\n+\n+\tblock_source_from_strbuf(&source, &buf);\n+\n+\terr = reftable_new_reader(&rd, &source, \"filename\");\n+\tassert_err(err);\n+\n+\tassert(hash_id == SHA1_ID);\n+\n+\terr = reftable_new_merged_table(&merged, tab, 1, SHA1_ID);\n+\tassert_err(err);\n+\n+\treftable_merged_table_free(merged);\n+\tstrbuf_release(&buf);\n+}\n+\n+/* XXX test refs_for(oid) */\n+\n+int merged_test_main(int argc, const char *argv[])\n+{\n+\treturn test_main(argc, argv);\n+}\ndiff --git a/reftable/pq.c b/reftable/pq.c\nnew file mode 100644\nindex 0000000000..81f7745f36\n--- /dev/null\n+++ b/reftable/pq.c\n@@ -0,0 +1,115 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"pq.h\"\n+\n+#include \"reftable.h\"\n+#include \"system.h\"\n+#include \"basics.h\"\n+\n+static int pq_less(struct pq_entry a, struct pq_entry b)\n+{\n+\tstruct strbuf ak = STRBUF_INIT;\n+\tstruct strbuf bk = STRBUF_INIT;\n+\tint cmp = 0;\n+\treftable_record_key(&a.rec, &ak);\n+\treftable_record_key(&b.rec, &bk);\n+\n+\tcmp = strbuf_cmp(&ak, &bk);\n+\n+\tstrbuf_release(&ak);\n+\tstrbuf_release(&bk);\n+\n+\tif (cmp == 0)\n+\t\treturn a.index > b.index;\n+\n+\treturn cmp < 0;\n+}\n+\n+struct pq_entry merged_iter_pqueue_top(struct merged_iter_pqueue pq)\n+{\n+\treturn pq.heap;\n+}\n+\n+int merged_iter_pqueue_is_empty(struct merged_iter_pqueue pq)\n+{\n+\treturn pq.len == 0;\n+}\n+\n+void merged_iter_pqueue_check(struct merged_iter_pqueue pq)\n+{\n+\tint i = 0;\n+\tfor (i = 1; i < pq.len; i++) {\n+\t\tint parent = (i - 1) / 2;\n+\n+\t\tassert(pq_less(pq.heap[parent], pq.heap[i]));\n+\t}\n+}\n+\n+struct pq_entry merged_iter_pqueue_remove(struct merged_iter_pqueue *pq)\n+{\n+\tint i = 0;\n+\tstruct pq_entry e = pq->heap;\n+\tpq->heap = pq->heap[pq->len - 1];\n+\tpq->len--;\n+\n+\ti = 0;\n+\twhile (i < pq->len) {\n+\t\tint min = i;\n+\t\tint j = 2 * i + 1;\n+\t\tint k = 2 * i + 2;\n+\t\tif (j < pq->len && pq_less(pq->heap[j], pq->heap[i])) {\n+\t\t\tmin = j;\n+\t\t}\n+\t\tif (k < pq->len && pq_less(pq->heap[k], pq->heap[min])) {\n+\t\t\tmin = k;\n+\t\t}\n+\n+\t\tif (min == i) {\n+\t\t\tbreak;\n+\t\t}\n+\n+\t\tSWAP(pq->heap[i], pq->heap[min]);\n+\t\ti = min;\n+\t}\n+\n+\treturn e;\n+}\n+\n+void merged_iter_pqueue_add(struct merged_iter_pqueue *pq, struct pq_entry e)\n+{\n+\tint i = 0;\n+\tif (pq->len == pq->cap) {\n+\t\tpq->cap = 2 * pq->cap + 1;\n+\t\tpq->heap = reftable_realloc(pq->heap,\n+\t\t\t\t\t pq->cap * sizeof(struct pq_entry));\n+\t}\n+\n+\tpq->heap[pq->len++] = e;\n+\ti = pq->len - 1;\n+\twhile (i > 0) {\n+\t\tint j = (i - 1) / 2;\n+\t\tif (pq_less(pq->heap[j], pq->heap[i])) {\n+\t\t\tbreak;\n+\t\t}\n+\n+\t\tSWAP(pq->heap[j], pq->heap[i]);\n+\n+\t\ti = j;\n+\t}\n+}\n+\n+void merged_iter_pqueue_clear(struct merged_iter_pqueue *pq)\n+{\n+\tint i = 0;\n+\tfor (i = 0; i < pq->len; i++) {\n+\t\treftable_record_destroy(&pq->heap[i].rec);\n+\t}\n+\tFREE_AND_NULL(pq->heap);\n+\tpq->len = pq->cap = 0;\n+}\ndiff --git a/reftable/pq.h b/reftable/pq.h\nnew file mode 100644\nindex 0000000000..9c2c0e0bfe\n--- /dev/null\n+++ b/reftable/pq.h\n@@ -0,0 +1,32 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#ifndef PQ_H\n+#define PQ_H\n+\n+#include \"record.h\"\n+\n+struct pq_entry {\n+\tint index;\n+\tstruct reftable_record rec;\n+};\n+\n+struct merged_iter_pqueue {\n+\tstruct pq_entry *heap;\n+\tsize_t len;\n+\tsize_t cap;\n+};\n+\n+struct pq_entry merged_iter_pqueue_top(struct merged_iter_pqueue pq);\n+int merged_iter_pqueue_is_empty(struct merged_iter_pqueue pq);\n+void merged_iter_pqueue_check(struct merged_iter_pqueue pq);\n+struct pq_entry merged_iter_pqueue_remove(struct merged_iter_pqueue *pq);\n+void merged_iter_pqueue_add(struct merged_iter_pqueue *pq, struct pq_entry e);\n+void merged_iter_pqueue_clear(struct merged_iter_pqueue *pq);\n+\n+#endif\ndiff --git a/reftable/refname.c b/reftable/refname.c\nnew file mode 100644\nindex 0000000000..9051c1f574\n--- /dev/null\n+++ b/reftable/refname.c\n@@ -0,0 +1,209 @@\n+/*\n+\n+ Use of this source code is governed by a BSD-style\n+ license that can be found in the LICENSE file or at\n+*/\n+\n+#include \"system.h\"\n+#include \"reftable.h\"\n+#include \"basics.h\"\n+#include \"refname.h\"\n+#include \"strbuf.h\"\n+\n+struct find_arg {\n+\tchar **names;\n+\tconst char *want;\n+};\n+\n+static int find_name(size_t k, void *arg)\n+{\n+\tstruct find_arg *f_arg = (struct find_arg *)arg;\n+\treturn strcmp(f_arg->names[k], f_arg->want) >= 0;\n+}\n+\n+static int modification_has_ref(struct modification *mod, const char *name)\n+{\n+\tstruct reftable_ref_record ref = { NULL };\n+\tint err = 0;\n+\n+\tif (mod->add_len > 0) {\n+\t\tstruct find_arg arg = {\n+\t\t\t.want = name,\n+\t\t};\n+\t\tint idx = binsearch(mod->add_len, find_name, &arg);\n+\t\t\treturn 0;\n+\t\t}\n+\t}\n+\n+\tif (mod->del_len > 0) {\n+\t\tstruct find_arg arg = {\n+\t\t\t.names = mod->del,\n+\t\t\t.want = name,\n+\t\t};\n+\t\tint idx = binsearch(mod->del_len, find_name, &arg);\n+\t\tif (idx < mod->del_len && !strcmp(mod->del[idx], name)) {\n+\t\t\treturn 1;\n+\t\t}\n+\t}\n+\n+\terr = reftable_table_read_ref(&mod->tab, name, &ref);\n+\treftable_ref_record_clear(&ref);\n+\treturn err;\n+}\n+\n+static void modification_clear(struct modification *mod)\n+{\n+\t/* don't delete the strings themselves; they're owned by ref records.\n+\t */\n+\tFREE_AND_NULL(mod->del);\n+\tmod->del_len = 0;\n+}\n+\n+static int modification_has_ref_with_prefix(struct modification *mod,\n+\t\t\t\t\t const char *prefix)\n+{\n+\tstruct reftable_iterator it = { NULL };\n+\tstruct reftable_ref_record ref = { NULL };\n+\tint err = 0;\n+\n+\tif (mod->add_len > 0) {\n+\t\tstruct find_arg arg = {\n+\t\t\t.want = prefix,\n+\t\t};\n+\t\tint idx = binsearch(mod->add_len, find_name, &arg);\n+\t\tif (idx < mod->add_len &&\n+\t\t\tgoto done;\n+\t}\n+\terr = reftable_table_seek_ref(&mod->tab, &it, prefix);\n+\tif (err)\n+\t\tgoto done;\n+\n+\twhile (1) {\n+\t\terr = reftable_iterator_next_ref(&it, &ref);\n+\t\tif (err)\n+\t\t\tgoto done;\n+\n+\t\tif (mod->del_len > 0) {\n+\t\t\tstruct find_arg arg = {\n+\t\t\t\t.names = mod->del,\n+\t\t\t\t.want = ref.refname,\n+\t\t\t};\n+\t\t\tint idx = binsearch(mod->del_len, find_name, &arg);\n+\t\t\tif (idx < mod->del_len &&\n+\t\t\t !strcmp(ref.refname, mod->del[idx])) {\n+\t\t\t\tcontinue;\n+\t\t\t}\n+\t\t}\n+\n+\t\tif (strncmp(ref.refname, prefix, strlen(prefix))) {\n+\t\t\terr = 1;\n+\t\t\tgoto done;\n+\t\t}\n+\t\terr = 0;\n+\t\tgoto done;\n+\t}\n+\n+done:\n+\treftable_ref_record_clear(&ref);\n+\treftable_iterator_destroy(&it);\n+\treturn err;\n+}\n+\n+static int validate_refname(const char *name)\n+{\n+\twhile (1) {\n+\t\tchar *next = strchr(name, '/');\n+\t\tif (!*name) {\n+\t\t\treturn REFTABLE_REFNAME_ERROR;\n+\t\t}\n+\t\tif (!next) {\n+\t\t\treturn 0;\n+\t\t}\n+\t\tif (next - name == 0 || (next - name == 1 && *name == '.') ||\n+\t\t (next - name == 2 && name == '.' && name == '.'))\n+\t\t\treturn REFTABLE_REFNAME_ERROR;\n+\t\tname = next + 1;\n+\t}\n+\treturn 0;\n+}\n+\n+\t\t\t\t struct reftable_ref_record *recs, size_t sz)\n+{\n+\tstruct modification mod = {\n+\t\t.tab = tab,\n+\t\t.add = reftable_calloc(sizeof(char *) * sz),\n+\t\t.del = reftable_calloc(sizeof(char *) * sz),\n+\t};\n+\tint i = 0;\n+\tint err = 0;\n+\tfor (; i < sz; i++) {\n+\t\tif (reftable_ref_record_is_deletion(&recs[i])) {\n+\t\t\tmod.del[mod.del_len++] = recs[i].refname;\n+\t\t} else {\n+\t\t}\n+\t}\n+\n+\terr = modification_validate(&mod);\n+\tmodification_clear(&mod);\n+\treturn err;\n+}\n+\n+static void strbuf_trim_component(struct strbuf *sl)\n+{\n+\twhile (sl->len > 0) {\n+\t\tint is_slash = (sl->buf[sl->len - 1] == '/');\n+\t\tstrbuf_setlen(sl, sl->len - 1);\n+\t\tif (is_slash)\n+\t\t\tbreak;\n+\t}\n+}\n+\n+int modification_validate(struct modification *mod)\n+{\n+\tstruct strbuf slashed = STRBUF_INIT;\n+\tint err = 0;\n+\tint i = 0;\n+\tfor (; i < mod->add_len; i++) {\n+\t\tif (err)\n+\t\t\tgoto done;\n+\t\tstrbuf_reset(&slashed);\n+\n+\t\terr = modification_has_ref_with_prefix(mod, slashed.buf);\n+\t\tif (err == 0) {\n+\t\t\terr = REFTABLE_NAME_CONFLICT;\n+\t\t\tgoto done;\n+\t\t}\n+\t\tif (err < 0)\n+\t\t\tgoto done;\n+\n+\t\tstrbuf_reset(&slashed);\n+\t\twhile (slashed.len) {\n+\t\t\tstrbuf_trim_component(&slashed);\n+\t\t\terr = modification_has_ref(mod, slashed.buf);\n+\t\t\tif (err == 0) {\n+\t\t\t\terr = REFTABLE_NAME_CONFLICT;\n+\t\t\t\tgoto done;\n+\t\t\t}\n+\t\t\tif (err < 0)\n+\t\t\t\tgoto done;\n+\t\t}\n+\t}\n+\terr = 0;\n+done:\n+\tstrbuf_release(&slashed);\n+\treturn err;\n+}\ndiff --git a/reftable/refname.h b/reftable/refname.h\nnew file mode 100644\nindex 0000000000..fcd645a99f\n--- /dev/null\n+++ b/reftable/refname.h\n@@ -0,0 +1,28 @@\n+/*\n+\n+ Use of this source code is governed by a BSD-style\n+ license that can be found in the LICENSE file or at\n+*/\n+#ifndef REFNAME_H\n+#define REFNAME_H\n+\n+#include \"reftable.h\"\n+\n+struct modification {\n+\tstruct reftable_table tab;\n+\n+\n+\tchar **del;\n+\tsize_t del_len;\n+};\n+\n+\t\t\t\t struct reftable_ref_record *recs, size_t sz);\n+\n+int modification_validate(struct modification *mod);\n+\n+#endif\ndiff --git a/reftable/refname_test.c b/reftable/refname_test.c\nnew file mode 100644\nindex 0000000000..6e9a15da38\n--- /dev/null\n+++ b/reftable/refname_test.c\n@@ -0,0 +1,100 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"reftable.h\"\n+\n+#include \"basics.h\"\n+#include \"block.h\"\n+#include \"blocksource.h\"\n+#include \"constants.h\"\n+#include \"record.h\"\n+#include \"refname.h\"\n+#include \"system.h\"\n+\n+#include \"test_framework.h\"\n+#include \"reftable-tests.h\"\n+\n+struct testcase {\n+\tchar *del;\n+\tint error_code;\n+};\n+\n+static void test_conflict(void)\n+{\n+\tstruct reftable_write_options opts = { 0 };\n+\tstruct strbuf buf = STRBUF_INIT;\n+\tstruct reftable_writer *w =\n+\tstruct reftable_ref_record rec = {\n+\t\t.refname = \"a/b\",\n+\t\t.target = \"destination\", /* make sure it's not a symref. */\n+\t\t.update_index = 1,\n+\t};\n+\tint err;\n+\tint i;\n+\tstruct reftable_block_source source = { NULL };\n+\tstruct reftable_reader *rd = NULL;\n+\tstruct reftable_table tab = { NULL };\n+\tstruct testcase cases[] = {\n+\t\t{ \"a/b/c\", NULL, REFTABLE_NAME_CONFLICT },\n+\t\t{ \"b\", NULL, 0 },\n+\t\t{ \"a\", NULL, REFTABLE_NAME_CONFLICT },\n+\t\t{ \"a\", \"a/b\", 0 },\n+\n+\t\t{ \"p/\", NULL, REFTABLE_REFNAME_ERROR },\n+\t\t{ \"p//q\", NULL, REFTABLE_REFNAME_ERROR },\n+\t\t{ \"p/./q\", NULL, REFTABLE_REFNAME_ERROR },\n+\t\t{ \"p/../q\", NULL, REFTABLE_REFNAME_ERROR },\n+\n+\t\t{ \"a/b/c\", \"a/b\", 0 },\n+\t\t{ NULL, \"a//b\", 0 },\n+\t};\n+\treftable_writer_set_limits(w, 1, 1);\n+\n+\tassert_err(err);\n+\n+\terr = reftable_writer_close(w);\n+\tassert_err(err);\n+\treftable_writer_free(w);\n+\n+\tblock_source_from_strbuf(&source, &buf);\n+\terr = reftable_new_reader(&rd, &source, \"filename\");\n+\tassert_err(err);\n+\n+\n+\tfor (i = 0; i < ARRAY_SIZE(cases); i++) {\n+\t\tstruct modification mod = {\n+\t\t\t.tab = tab,\n+\t\t};\n+\n+\t\tif (cases[i].add != NULL) {\n+\t\t}\n+\t\tif (cases[i].del != NULL) {\n+\t\t\tmod.del = &cases[i].del;\n+\t\t\tmod.del_len = 1;\n+\t\t}\n+\n+\t\terr = modification_validate(&mod);\n+\t\tassert(err == cases[i].error_code);\n+\t}\n+\n+\tstrbuf_release(&buf);\n+}\n+\n+int refname_test_main(int argc, const char *argv[])\n+{\n+\treturn test_main(argc, argv);\n+}\ndiff --git a/reftable/reftable.c b/reftable/reftable.c\nindex 1425aef6f2..0f3bf0291e 100644\n--- a/reftable/reftable.c\n+++ b/reftable/reftable.c\n@@ -44,7 +44,7 @@ int reftable_table_seek_ref(struct reftable_table *tab,\nstruct reftable_ref_record ref = {\n.refname = (char *)name,\n};\n-\tstruct reftable_record rec = { 0 };\n+\tstruct reftable_record rec = { NULL };\nreftable_record_from_ref(&rec, &ref);\nreturn tab->ops->seek_record(tab->table_arg, it, &rec);\n}\n@@ -60,7 +60,7 @@ void reftable_table_from_reader(struct reftable_table *tab,\nint reftable_table_read_ref(struct reftable_table *tab, const char *name,\nstruct reftable_ref_record *ref)\n{\n-\tstruct reftable_iterator it = { 0 };\n+\tstruct reftable_iterator it = { NULL };\nint err = reftable_table_seek_ref(tab, &it, name);\nif (err)\ngoto done;\ndiff --git a/reftable/stack.c b/reftable/stack.c\nnew file mode 100644\nindex 0000000000..b20bee407b\n--- /dev/null\n+++ b/reftable/stack.c\n@@ -0,0 +1,1240 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"stack.h\"\n+\n+#include \"system.h\"\n+#include \"merged.h\"\n+#include \"refname.h\"\n+#include \"reftable.h\"\n+#include \"writer.h\"\n+\n+\t\t\t int (*write_table)(struct reftable_writer *wr,\n+\t\t\t\t\t void *arg),\n+\t\t\t void *arg);\n+static int stack_write_compact(struct reftable_stack *st,\n+\t\t\t struct reftable_writer *wr, int first, int last,\n+\t\t\t struct reftable_log_expiry_config *config);\n+\t\t\t\tconst char *new_tab_name);\n+\t\t\t\t\t int reuse_open);\n+\n+int reftable_new_stack(struct reftable_stack **dest, const char *dir,\n+\t\t struct reftable_write_options config)\n+{\n+\tstruct reftable_stack *p =\n+\t\treftable_calloc(sizeof(struct reftable_stack));\n+\tstruct strbuf list_file_name = STRBUF_INIT;\n+\tint err = 0;\n+\n+\tif (config.hash_id == 0) {\n+\t\tconfig.hash_id = SHA1_ID;\n+\t}\n+\n+\t*dest = NULL;\n+\n+\tstrbuf_reset(&list_file_name);\n+\n+\tp->list_file = strbuf_detach(&list_file_name, NULL);\n+\tp->reftable_dir = xstrdup(dir);\n+\tp->config = config;\n+\n+\tif (err < 0) {\n+\t\treftable_stack_destroy(p);\n+\t} else {\n+\t\t*dest = p;\n+\t}\n+\treturn err;\n+}\n+\n+static int fd_read_lines(int fd, char ***namesp)\n+{\n+\toff_t size = lseek(fd, 0, SEEK_END);\n+\tchar *buf = NULL;\n+\tint err = 0;\n+\tif (size < 0) {\n+\t\terr = REFTABLE_IO_ERROR;\n+\t\tgoto done;\n+\t}\n+\terr = lseek(fd, 0, SEEK_SET);\n+\tif (err < 0) {\n+\t\terr = REFTABLE_IO_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+\tbuf = reftable_malloc(size + 1);\n+\tif (read(fd, buf, size) != size) {\n+\t\terr = REFTABLE_IO_ERROR;\n+\t\tgoto done;\n+\t}\n+\tbuf[size] = 0;\n+\n+\tparse_names(buf, size, namesp);\n+\n+done:\n+\treftable_free(buf);\n+\treturn err;\n+}\n+\n+int read_lines(const char *filename, char ***namesp)\n+{\n+\tint fd = open(filename, O_RDONLY, 0644);\n+\tint err = 0;\n+\tif (fd < 0) {\n+\t\tif (errno == ENOENT) {\n+\t\t\t*namesp = reftable_calloc(sizeof(char *));\n+\t\t\treturn 0;\n+\t\t}\n+\n+\t\treturn REFTABLE_IO_ERROR;\n+\t}\n+\tclose(fd);\n+\treturn err;\n+}\n+\n+struct reftable_merged_table *\n+reftable_stack_merged_table(struct reftable_stack *st)\n+{\n+\treturn st->merged;\n+}\n+\n+/* Close and free the stack */\n+void reftable_stack_destroy(struct reftable_stack *st)\n+{\n+\tif (st->merged != NULL) {\n+\t\treftable_merged_table_free(st->merged);\n+\t\tst->merged = NULL;\n+\t}\n+\n+\tif (st->readers != NULL) {\n+\t\tint i = 0;\n+\t\tfor (i = 0; i < st->readers_len; i++) {\n+\t\t}\n+\t}\n+\tFREE_AND_NULL(st->list_file);\n+\tFREE_AND_NULL(st->reftable_dir);\n+\treftable_free(st);\n+}\n+\n+\t\t\t\t\t\t int cur_len)\n+{\n+\t\treftable_calloc(sizeof(struct reftable_reader *) * cur_len);\n+\tint i = 0;\n+\tfor (i = 0; i < cur_len; i++) {\n+\t}\n+\treturn cur;\n+}\n+\n+static int reftable_stack_reload_once(struct reftable_stack *st, char **names,\n+\t\t\t\t int reuse_open)\n+{\n+\tint cur_len = st->merged == NULL ? 0 : st->merged->stack_len;\n+\tint err = 0;\n+\tint names_len = names_length(names);\n+\t\treftable_calloc(sizeof(struct reftable_reader *) * names_len);\n+\tstruct reftable_table *new_tables =\n+\t\treftable_calloc(sizeof(struct reftable_table) * names_len);\n+\tstruct reftable_merged_table *new_merged = NULL;\n+\tint i;\n+\n+\twhile (*names) {\n+\t\tstruct reftable_reader *rd = NULL;\n+\t\tchar *name = *names++;\n+\n+\t\t/* this is linear; we assume compaction keeps the number of\n+\t\t tables under control so this is not quadratic. */\n+\t\tint j = 0;\n+\t\tfor (j = 0; reuse_open && j < cur_len; j++) {\n+\t\t\tif (cur[j] != NULL && 0 == strcmp(cur[j]->name, name)) {\n+\t\t\t\trd = cur[j];\n+\t\t\t\tcur[j] = NULL;\n+\t\t\t\tbreak;\n+\t\t\t}\n+\t\t}\n+\n+\t\tif (rd == NULL) {\n+\t\t\tstruct reftable_block_source src = { NULL };\n+\t\t\tstruct strbuf table_path = STRBUF_INIT;\n+\n+\t\t\terr = reftable_block_source_from_file(&src,\n+\t\t\t\t\t\t\t table_path.buf);\n+\t\t\tstrbuf_release(&table_path);\n+\n+\t\t\tif (err < 0)\n+\t\t\t\tgoto done;\n+\n+\t\t\terr = reftable_new_reader(&rd, &src, name);\n+\t\t\tif (err < 0)\n+\t\t\t\tgoto done;\n+\t\t}\n+\n+\t}\n+\n+\t/* success! */\n+\terr = reftable_new_merged_table(&new_merged, new_tables,\n+\tif (err < 0)\n+\t\tgoto done;\n+\n+\tnew_tables = NULL;\n+\tif (st->merged != NULL) {\n+\t\tmerged_table_clear(st->merged);\n+\t\treftable_merged_table_free(st->merged);\n+\t}\n+\tif (st->readers != NULL) {\n+\t}\n+\n+\tnew_merged->suppress_deletions = 1;\n+\tst->merged = new_merged;\n+\tfor (i = 0; i < cur_len; i++) {\n+\t\tif (cur[i] != NULL) {\n+\t\t}\n+\t}\n+\n+done:\n+\tfor (i = 0; i < new_readers_len; i++) {\n+\t}\n+\treftable_free(new_tables);\n+\treftable_free(cur);\n+\treturn err;\n+}\n+\n+/* return negative if a before b. */\n+static int tv_cmp(struct timeval *a, struct timeval *b)\n+{\n+\ttime_t diff = a->tv_sec - b->tv_sec;\n+\tint udiff = a->tv_usec - b->tv_usec;\n+\n+\tif (diff != 0)\n+\t\treturn diff;\n+\n+\treturn udiff;\n+}\n+\n+\t\t\t\t\t int reuse_open)\n+{\n+\tstruct timeval deadline = { 0 };\n+\tint err = gettimeofday(&deadline, NULL);\n+\tint64_t delay = 0;\n+\tint tries = 0;\n+\tif (err < 0)\n+\t\treturn err;\n+\n+\twhile (1) {\n+\t\tchar **names = NULL;\n+\t\tchar **names_after = NULL;\n+\t\tstruct timeval now = { 0 };\n+\t\tint err = gettimeofday(&now, NULL);\n+\t\tint err2 = 0;\n+\t\tif (err < 0) {\n+\t\t\treturn err;\n+\t\t}\n+\n+\t\t/* Only look at deadlines after the first few times. This\n+\t\t simplifies debugging in GDB */\n+\t\ttries++;\n+\t\tif (tries > 3 && tv_cmp(&now, &deadline) >= 0) {\n+\t\t\tbreak;\n+\t\t}\n+\n+\t\tif (err < 0) {\n+\t\t\tfree_names(names);\n+\t\t\treturn err;\n+\t\t}\n+\t\terr = reftable_stack_reload_once(st, names, reuse_open);\n+\t\tif (err == 0) {\n+\t\t\tfree_names(names);\n+\t\t\tbreak;\n+\t\t}\n+\t\tif (err != REFTABLE_NOT_EXIST_ERROR) {\n+\t\t\tfree_names(names);\n+\t\t\treturn err;\n+\t\t}\n+\n+\t\t/* err == REFTABLE_NOT_EXIST_ERROR can be caused by a concurrent\n+\t\t writer. Check if there was one by checking if the name list\n+\t\t changed.\n+\t\t*/\n+\t\tif (err2 < 0) {\n+\t\t\tfree_names(names);\n+\t\t\treturn err2;\n+\t\t}\n+\n+\t\tif (names_equal(names_after, names)) {\n+\t\t\tfree_names(names);\n+\t\t\tfree_names(names_after);\n+\t\t\treturn err;\n+\t\t}\n+\t\tfree_names(names);\n+\t\tfree_names(names_after);\n+\n+\t\tdelay = delay + (delay * rand()) / RAND_MAX + 1;\n+\t\tsleep_millisec(delay);\n+\t}\n+\n+\treturn 0;\n+}\n+\n+/* -1 = error\n+ 0 = up to date\n+ 1 = changed. */\n+static int stack_uptodate(struct reftable_stack *st)\n+{\n+\tchar **names = NULL;\n+\tint err = read_lines(st->list_file, &names);\n+\tint i = 0;\n+\tif (err < 0)\n+\t\treturn err;\n+\n+\tfor (i = 0; i < st->readers_len; i++) {\n+\t\tif (names[i] == NULL) {\n+\t\t\terr = 1;\n+\t\t\tgoto done;\n+\t\t}\n+\n+\t\t\terr = 1;\n+\t\t\tgoto done;\n+\t\t}\n+\t}\n+\n+\tif (names[st->merged->stack_len] != NULL) {\n+\t\terr = 1;\n+\t\tgoto done;\n+\t}\n+\n+done:\n+\tfree_names(names);\n+\treturn err;\n+}\n+\n+{\n+\tint err = stack_uptodate(st);\n+\tif (err > 0)\n+\treturn err;\n+}\n+\n+\t\t int (*write)(struct reftable_writer *wr, void *arg),\n+\t\t void *arg)\n+{\n+\tint err = stack_try_add(st, write, arg);\n+\tif (err < 0) {\n+\t\tif (err == REFTABLE_LOCK_ERROR) {\n+\t\t\t/* Ignore error return, we want to propagate\n+\t\t\t REFTABLE_LOCK_ERROR.\n+\t\t\t*/\n+\t\t}\n+\t\treturn err;\n+\t}\n+\n+\tif (!st->disable_auto_compact)\n+\t\treturn reftable_stack_auto_compact(st);\n+\n+\treturn 0;\n+}\n+\n+static void format_name(struct strbuf *dest, uint64_t min, uint64_t max)\n+{\n+\tchar buf;\n+\tsnprintf(buf, sizeof(buf), \"0x%012\" PRIx64 \"-0x%012\" PRIx64, min, max);\n+\tstrbuf_reset(dest);\n+}\n+\n+\tint lock_file_fd;\n+\tstruct strbuf lock_file_name;\n+\tstruct reftable_stack *stack;\n+\tchar **names;\n+\tchar **new_tables;\n+\tint new_tables_len;\n+\tuint64_t next_update_index;\n+};\n+\n+\t{ \\\n+\t\t.lock_file_name = STRBUF_INIT \\\n+\t}\n+\n+\t\t\t\t\tstruct reftable_stack *st)\n+{\n+\tint err = 0;\n+\n+\n+\t\t\t\t O_EXCL | O_CREAT | O_WRONLY, 0644);\n+\tif (add->lock_file_fd < 0) {\n+\t\tif (errno == EEXIST) {\n+\t\t\terr = REFTABLE_LOCK_ERROR;\n+\t\t} else {\n+\t\t\terr = REFTABLE_IO_ERROR;\n+\t\t}\n+\t\tgoto done;\n+\t}\n+\terr = stack_uptodate(st);\n+\tif (err < 0)\n+\t\tgoto done;\n+\n+\tif (err > 1) {\n+\t\terr = REFTABLE_LOCK_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+done:\n+\tif (err) {\n+\t}\n+\treturn err;\n+}\n+\n+{\n+\tint i = 0;\n+\tstruct strbuf nm = STRBUF_INIT;\n+\tfor (i = 0; i < add->new_tables_len; i++) {\n+\t\tstrbuf_reset(&nm);\n+\t}\n+\n+\tif (add->lock_file_fd > 0) {\n+\t}\n+\tif (add->lock_file_name.len > 0) {\n+\t}\n+\n+\tstrbuf_release(&nm);\n+}\n+\n+{\n+\tif (add == NULL) {\n+\t\treturn;\n+\t}\n+}\n+\n+{\n+\tstruct strbuf table_list = STRBUF_INIT;\n+\tint i = 0;\n+\tint err = 0;\n+\t\tgoto done;\n+\n+\tfor (i = 0; i < add->stack->merged->stack_len; i++) {\n+\t}\n+\tfor (i = 0; i < add->new_tables_len; i++) {\n+\t}\n+\n+\terr = write(add->lock_file_fd, table_list.buf, table_list.len);\n+\tstrbuf_release(&table_list);\n+\tif (err < 0) {\n+\t\terr = REFTABLE_IO_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+\tif (err < 0) {\n+\t\terr = REFTABLE_IO_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+\tif (err < 0) {\n+\t\terr = REFTABLE_IO_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+\n+done:\n+\treturn err;\n+}\n+\n+\t\t\t\tstruct reftable_stack *st)\n+{\n+\tint err = 0;\n+\t*dest = reftable_calloc(sizeof(**dest));\n+\t**dest = empty;\n+\tif (err) {\n+\t\treftable_free(*dest);\n+\t\t*dest = NULL;\n+\t}\n+\treturn err;\n+}\n+\n+\t\t\t int (*write_table)(struct reftable_writer *wr,\n+\t\t\t\t\t void *arg),\n+\t\t\t void *arg)\n+{\n+\tif (err < 0)\n+\t\tgoto done;\n+\tif (err > 0) {\n+\t\terr = REFTABLE_LOCK_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+\tif (err < 0)\n+\t\tgoto done;\n+\n+done:\n+\treturn err;\n+}\n+\n+\t\t\t int (*write_table)(struct reftable_writer *wr,\n+\t\t\t\t\t void *arg),\n+\t\t\t void *arg)\n+{\n+\tstruct strbuf temp_tab_file_name = STRBUF_INIT;\n+\tstruct strbuf tab_file_name = STRBUF_INIT;\n+\tstruct strbuf next_name = STRBUF_INIT;\n+\tstruct reftable_writer *wr = NULL;\n+\tint err = 0;\n+\tint tab_fd = 0;\n+\n+\tstrbuf_reset(&next_name);\n+\n+\n+\ttab_fd = mkstemp(temp_tab_file_name.buf);\n+\tif (tab_fd < 0) {\n+\t\terr = REFTABLE_IO_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+\twr = reftable_new_writer(reftable_fd_write, &tab_fd,\n+\terr = write_table(wr, arg);\n+\tif (err < 0)\n+\t\tgoto done;\n+\n+\terr = reftable_writer_close(wr);\n+\tif (err == REFTABLE_EMPTY_TABLE_ERROR) {\n+\t\terr = 0;\n+\t\tgoto done;\n+\t}\n+\tif (err < 0)\n+\t\tgoto done;\n+\n+\terr = close(tab_fd);\n+\ttab_fd = 0;\n+\tif (err < 0) {\n+\t\terr = REFTABLE_IO_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+\tif (err < 0)\n+\t\tgoto done;\n+\n+\tif (wr->min_update_index < add->next_update_index) {\n+\t\terr = REFTABLE_API_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+\tformat_name(&next_name, wr->min_update_index, wr->max_update_index);\n+\n+\n+\t/* TODO: should check destination out of paranoia */\n+\terr = rename(temp_tab_file_name.buf, tab_file_name.buf);\n+\tif (err < 0) {\n+\t\terr = REFTABLE_IO_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+done:\n+\tif (tab_fd > 0) {\n+\t\tclose(tab_fd);\n+\t\ttab_fd = 0;\n+\t}\n+\tif (temp_tab_file_name.len > 0) {\n+\t}\n+\n+\tstrbuf_release(&temp_tab_file_name);\n+\tstrbuf_release(&tab_file_name);\n+\tstrbuf_release(&next_name);\n+\treftable_writer_free(wr);\n+\treturn err;\n+}\n+\n+uint64_t reftable_stack_next_update_index(struct reftable_stack *st)\n+{\n+\tint sz = st->merged->stack_len;\n+\tif (sz > 0)\n+\t\t 1;\n+\treturn 1;\n+}\n+\n+static int stack_compact_locked(struct reftable_stack *st, int first, int last,\n+\t\t\t\tstruct strbuf *temp_tab,\n+\t\t\t\tstruct reftable_log_expiry_config *config)\n+{\n+\tstruct strbuf next_name = STRBUF_INIT;\n+\tint tab_fd = -1;\n+\tstruct reftable_writer *wr = NULL;\n+\tint err = 0;\n+\n+\tformat_name(&next_name,\n+\n+\tstrbuf_reset(temp_tab);\n+\n+\ttab_fd = mkstemp(temp_tab->buf);\n+\twr = reftable_new_writer(reftable_fd_write, &tab_fd, &st->config);\n+\n+\terr = stack_write_compact(st, wr, first, last, config);\n+\tif (err < 0)\n+\t\tgoto done;\n+\terr = reftable_writer_close(wr);\n+\tif (err < 0)\n+\t\tgoto done;\n+\n+\terr = close(tab_fd);\n+\ttab_fd = 0;\n+\n+done:\n+\treftable_writer_free(wr);\n+\tif (tab_fd > 0) {\n+\t\tclose(tab_fd);\n+\t\ttab_fd = 0;\n+\t}\n+\tif (err != 0 && temp_tab->len > 0) {\n+\t\tstrbuf_release(temp_tab);\n+\t}\n+\tstrbuf_release(&next_name);\n+\treturn err;\n+}\n+\n+static int stack_write_compact(struct reftable_stack *st,\n+\t\t\t struct reftable_writer *wr, int first, int last,\n+\t\t\t struct reftable_log_expiry_config *config)\n+{\n+\tint subtabs_len = last - first + 1;\n+\tstruct reftable_table *subtabs = reftable_calloc(\n+\t\tsizeof(struct reftable_table) * (last - first + 1));\n+\tstruct reftable_merged_table *mt = NULL;\n+\tint err = 0;\n+\tstruct reftable_iterator it = { NULL };\n+\tstruct reftable_ref_record ref = { NULL };\n+\tstruct reftable_log_record log = { NULL };\n+\n+\tuint64_t entries = 0;\n+\n+\tint i = 0, j = 0;\n+\tfor (i = first, j = 0; i <= last; i++) {\n+\t\tst->stats.bytes += t->size;\n+\t}\n+\n+\terr = reftable_new_merged_table(&mt, subtabs, subtabs_len,\n+\t\t\t\t\tst->config.hash_id);\n+\tif (err < 0) {\n+\t\treftable_free(subtabs);\n+\t\tgoto done;\n+\t}\n+\n+\terr = reftable_merged_table_seek_ref(mt, &it, \"\");\n+\tif (err < 0)\n+\t\tgoto done;\n+\n+\twhile (1) {\n+\t\terr = reftable_iterator_next_ref(&it, &ref);\n+\t\tif (err > 0) {\n+\t\t\terr = 0;\n+\t\t\tbreak;\n+\t\t}\n+\t\tif (err < 0) {\n+\t\t\tbreak;\n+\t\t}\n+\t\tif (first == 0 && reftable_ref_record_is_deletion(&ref)) {\n+\t\t\tcontinue;\n+\t\t}\n+\n+\t\tif (err < 0) {\n+\t\t\tbreak;\n+\t\t}\n+\t\tentries++;\n+\t}\n+\treftable_iterator_destroy(&it);\n+\n+\terr = reftable_merged_table_seek_log(mt, &it, \"\");\n+\tif (err < 0)\n+\t\tgoto done;\n+\n+\twhile (1) {\n+\t\terr = reftable_iterator_next_log(&it, &log);\n+\t\tif (err > 0) {\n+\t\t\terr = 0;\n+\t\t\tbreak;\n+\t\t}\n+\t\tif (err < 0) {\n+\t\t\tbreak;\n+\t\t}\n+\t\tif (first == 0 && reftable_log_record_is_deletion(&log)) {\n+\t\t\tcontinue;\n+\t\t}\n+\n+\t\tif (config != NULL && config->time > 0 &&\n+\t\t log.time < config->time) {\n+\t\t\tcontinue;\n+\t\t}\n+\n+\t\tif (config != NULL && config->min_update_index > 0 &&\n+\t\t log.update_index < config->min_update_index) {\n+\t\t\tcontinue;\n+\t\t}\n+\n+\t\tif (err < 0) {\n+\t\t\tbreak;\n+\t\t}\n+\t\tentries++;\n+\t}\n+\n+done:\n+\treftable_iterator_destroy(&it);\n+\tif (mt != NULL) {\n+\t\tmerged_table_clear(mt);\n+\t\treftable_merged_table_free(mt);\n+\t}\n+\treftable_ref_record_clear(&ref);\n+\treftable_log_record_clear(&log);\n+\tst->stats.entries_written += entries;\n+\treturn err;\n+}\n+\n+/* < 0: error. 0 == OK, > 0 attempt failed; could retry. */\n+static int stack_compact_range(struct reftable_stack *st, int first, int last,\n+\t\t\t struct reftable_log_expiry_config *expiry)\n+{\n+\tstruct strbuf temp_tab_file_name = STRBUF_INIT;\n+\tstruct strbuf new_table_name = STRBUF_INIT;\n+\tstruct strbuf lock_file_name = STRBUF_INIT;\n+\tstruct strbuf ref_list_contents = STRBUF_INIT;\n+\tstruct strbuf new_table_path = STRBUF_INIT;\n+\tint err = 0;\n+\tint have_lock = 0;\n+\tint lock_file_fd = 0;\n+\tint compact_count = last - first + 1;\n+\tchar **listp = NULL;\n+\tchar **delete_on_success =\n+\t\treftable_calloc(sizeof(char *) * (compact_count + 1));\n+\tchar **subtable_locks =\n+\t\treftable_calloc(sizeof(char *) * (compact_count + 1));\n+\tint i = 0;\n+\tint j = 0;\n+\tint is_empty_table = 0;\n+\n+\tif (first > last || (expiry == NULL && first == last)) {\n+\t\terr = 0;\n+\t\tgoto done;\n+\t}\n+\n+\tst->stats.attempts++;\n+\n+\tstrbuf_reset(&lock_file_name);\n+\n+\tlock_file_fd =\n+\t\topen(lock_file_name.buf, O_EXCL | O_CREAT | O_WRONLY, 0644);\n+\tif (lock_file_fd < 0) {\n+\t\tif (errno == EEXIST) {\n+\t\t\terr = 1;\n+\t\t} else {\n+\t\t\terr = REFTABLE_IO_ERROR;\n+\t\t}\n+\t\tgoto done;\n+\t}\n+\t/* Don't want to write to the lock for now. */\n+\tclose(lock_file_fd);\n+\tlock_file_fd = 0;\n+\n+\thave_lock = 1;\n+\terr = stack_uptodate(st);\n+\tif (err != 0)\n+\t\tgoto done;\n+\n+\tfor (i = first, j = 0; i <= last; i++) {\n+\t\tstruct strbuf subtab_file_name = STRBUF_INIT;\n+\t\tstruct strbuf subtab_lock = STRBUF_INIT;\n+\t\tint sublock_file_fd = -1;\n+\n+\n+\t\tstrbuf_reset(&subtab_lock);\n+\n+\t\tsublock_file_fd = open(subtab_lock.buf,\n+\t\t\t\t O_EXCL | O_CREAT | O_WRONLY, 0644);\n+\t\tif (sublock_file_fd > 0) {\n+\t\t\tclose(sublock_file_fd);\n+\t\t} else if (sublock_file_fd < 0) {\n+\t\t\tif (errno == EEXIST) {\n+\t\t\t\terr = 1;\n+\t\t\t} else {\n+\t\t\t\terr = REFTABLE_IO_ERROR;\n+\t\t\t}\n+\t\t}\n+\n+\t\tsubtable_locks[j] = subtab_lock.buf;\n+\t\tdelete_on_success[j] = subtab_file_name.buf;\n+\t\tj++;\n+\n+\t\tif (err != 0)\n+\t\t\tgoto done;\n+\t}\n+\n+\tif (err < 0)\n+\t\tgoto done;\n+\thave_lock = 0;\n+\n+\terr = stack_compact_locked(st, first, last, &temp_tab_file_name,\n+\t\t\t\t expiry);\n+\t/* Compaction + tombstones can create an empty table out of non-empty\n+\t * tables. */\n+\tis_empty_table = (err == REFTABLE_EMPTY_TABLE_ERROR);\n+\tif (is_empty_table) {\n+\t\terr = 0;\n+\t}\n+\tif (err < 0)\n+\t\tgoto done;\n+\n+\tlock_file_fd =\n+\t\topen(lock_file_name.buf, O_EXCL | O_CREAT | O_WRONLY, 0644);\n+\tif (lock_file_fd < 0) {\n+\t\tif (errno == EEXIST) {\n+\t\t\terr = 1;\n+\t\t} else {\n+\t\t\terr = REFTABLE_IO_ERROR;\n+\t\t}\n+\t\tgoto done;\n+\t}\n+\thave_lock = 1;\n+\n+\n+\tstrbuf_reset(&new_table_path);\n+\n+\tif (!is_empty_table) {\n+\t\terr = rename(temp_tab_file_name.buf, new_table_path.buf);\n+\t\tif (err < 0) {\n+\t\t\terr = REFTABLE_IO_ERROR;\n+\t\t\tgoto done;\n+\t\t}\n+\t}\n+\n+\tfor (i = 0; i < first; i++) {\n+\t}\n+\tif (!is_empty_table) {\n+\t}\n+\tfor (i = last + 1; i < st->merged->stack_len; i++) {\n+\t}\n+\n+\terr = write(lock_file_fd, ref_list_contents.buf, ref_list_contents.len);\n+\tif (err < 0) {\n+\t\terr = REFTABLE_IO_ERROR;\n+\t\tgoto done;\n+\t}\n+\terr = close(lock_file_fd);\n+\tlock_file_fd = 0;\n+\tif (err < 0) {\n+\t\terr = REFTABLE_IO_ERROR;\n+\t\tgoto done;\n+\t}\n+\n+\terr = rename(lock_file_name.buf, st->list_file);\n+\tif (err < 0) {\n+\t\terr = REFTABLE_IO_ERROR;\n+\t\tgoto done;\n+\t}\n+\thave_lock = 0;\n+\n+\t/* Reload the stack before deleting. On windows, we can only delete the\n+\t files after we closed them.\n+\t*/\n+\terr = reftable_stack_reload_maybe_reuse(st, first < last);\n+\n+\tlistp = delete_on_success;\n+\twhile (*listp) {\n+\t\tif (strcmp(*listp, new_table_path.buf)) {\n+\t\t}\n+\t\tlistp++;\n+\t}\n+\n+done:\n+\tfree_names(delete_on_success);\n+\n+\tlistp = subtable_locks;\n+\twhile (*listp) {\n+\t\tlistp++;\n+\t}\n+\tfree_names(subtable_locks);\n+\tif (lock_file_fd > 0) {\n+\t\tclose(lock_file_fd);\n+\t\tlock_file_fd = 0;\n+\t}\n+\tif (have_lock) {\n+\t}\n+\tstrbuf_release(&new_table_name);\n+\tstrbuf_release(&new_table_path);\n+\tstrbuf_release(&ref_list_contents);\n+\tstrbuf_release(&temp_tab_file_name);\n+\tstrbuf_release(&lock_file_name);\n+\treturn err;\n+}\n+\n+int reftable_stack_compact_all(struct reftable_stack *st,\n+\t\t\t struct reftable_log_expiry_config *config)\n+{\n+\treturn stack_compact_range(st, 0, st->merged->stack_len - 1, config);\n+}\n+\n+static int stack_compact_range_stats(struct reftable_stack *st, int first,\n+\t\t\t\t int last,\n+\t\t\t\t struct reftable_log_expiry_config *config)\n+{\n+\tint err = stack_compact_range(st, first, last, config);\n+\tif (err > 0) {\n+\t\tst->stats.failures++;\n+\t}\n+\treturn err;\n+}\n+\n+static int segment_size(struct segment *s)\n+{\n+\treturn s->end - s->start;\n+}\n+\n+int fastlog2(uint64_t sz)\n+{\n+\tint l = 0;\n+\tif (sz == 0)\n+\t\treturn 0;\n+\tfor (; sz; sz /= 2) {\n+\t\tl++;\n+\t}\n+\treturn l - 1;\n+}\n+\n+struct segment *sizes_to_segments(int *seglen, uint64_t *sizes, int n)\n+{\n+\tstruct segment *segs = reftable_calloc(sizeof(struct segment) * n);\n+\tint next = 0;\n+\tstruct segment cur = { 0 };\n+\tint i = 0;\n+\n+\tif (n == 0) {\n+\t\t*seglen = 0;\n+\t\treturn segs;\n+\t}\n+\tfor (i = 0; i < n; i++) {\n+\t\tint log = fastlog2(sizes[i]);\n+\t\tif (cur.log != log && cur.bytes > 0) {\n+\t\t\tstruct segment fresh = {\n+\t\t\t\t.start = i,\n+\t\t\t};\n+\n+\t\t\tsegs[next++] = cur;\n+\t\t\tcur = fresh;\n+\t\t}\n+\n+\t\tcur.log = log;\n+\t\tcur.end = i + 1;\n+\t\tcur.bytes += sizes[i];\n+\t}\n+\tsegs[next++] = cur;\n+\t*seglen = next;\n+\treturn segs;\n+}\n+\n+struct segment suggest_compaction_segment(uint64_t *sizes, int n)\n+{\n+\tint seglen = 0;\n+\tstruct segment *segs = sizes_to_segments(&seglen, sizes, n);\n+\tstruct segment min_seg = {\n+\t\t.log = 64,\n+\t};\n+\tint i = 0;\n+\tfor (i = 0; i < seglen; i++) {\n+\t\tif (segment_size(&segs[i]) == 1) {\n+\t\t\tcontinue;\n+\t\t}\n+\n+\t\tif (segs[i].log < min_seg.log) {\n+\t\t\tmin_seg = segs[i];\n+\t\t}\n+\t}\n+\n+\twhile (min_seg.start > 0) {\n+\t\tint prev = min_seg.start - 1;\n+\t\tif (fastlog2(min_seg.bytes) < fastlog2(sizes[prev])) {\n+\t\t\tbreak;\n+\t\t}\n+\n+\t\tmin_seg.start = prev;\n+\t\tmin_seg.bytes += sizes[prev];\n+\t}\n+\n+\treftable_free(segs);\n+\treturn min_seg;\n+}\n+\n+static uint64_t *stack_table_sizes_for_compaction(struct reftable_stack *st)\n+{\n+\tuint64_t *sizes =\n+\t\treftable_calloc(sizeof(uint64_t) * st->merged->stack_len);\n+\tint version = (st->config.hash_id == SHA1_ID) ? 1 : 2;\n+\tint i = 0;\n+\tfor (i = 0; i < st->merged->stack_len; i++) {\n+\t}\n+\treturn sizes;\n+}\n+\n+int reftable_stack_auto_compact(struct reftable_stack *st)\n+{\n+\tuint64_t *sizes = stack_table_sizes_for_compaction(st);\n+\tstruct segment seg =\n+\t\tsuggest_compaction_segment(sizes, st->merged->stack_len);\n+\treftable_free(sizes);\n+\tif (segment_size(&seg) > 0)\n+\t\treturn stack_compact_range_stats(st, seg.start, seg.end - 1,\n+\t\t\t\t\t\t NULL);\n+\n+\treturn 0;\n+}\n+\n+struct reftable_compaction_stats *\n+reftable_stack_compaction_stats(struct reftable_stack *st)\n+{\n+\treturn &st->stats;\n+}\n+\n+int reftable_stack_read_ref(struct reftable_stack *st, const char *refname,\n+\t\t\t struct reftable_ref_record *ref)\n+{\n+\tstruct reftable_table tab = { NULL };\n+\treftable_table_from_merged_table(&tab, reftable_stack_merged_table(st));\n+}\n+\n+int reftable_stack_read_log(struct reftable_stack *st, const char *refname,\n+\t\t\t struct reftable_log_record *log)\n+{\n+\tstruct reftable_iterator it = { NULL };\n+\tstruct reftable_merged_table *mt = reftable_stack_merged_table(st);\n+\tint err = reftable_merged_table_seek_log(mt, &it, refname);\n+\tif (err)\n+\t\tgoto done;\n+\n+\terr = reftable_iterator_next_log(&it, log);\n+\tif (err)\n+\t\tgoto done;\n+\n+\tif (strcmp(log->refname, refname) ||\n+\t reftable_log_record_is_deletion(log)) {\n+\t\terr = 1;\n+\t\tgoto done;\n+\t}\n+\n+done:\n+\tif (err) {\n+\t\treftable_log_record_clear(log);\n+\t}\n+\treftable_iterator_destroy(&it);\n+\treturn err;\n+}\n+\n+\t\t\t\tconst char *new_tab_name)\n+{\n+\tint err = 0;\n+\tstruct reftable_block_source src = { NULL };\n+\tstruct reftable_reader *rd = NULL;\n+\tstruct reftable_table tab = { NULL };\n+\tstruct reftable_ref_record *refs = NULL;\n+\tstruct reftable_iterator it = { NULL };\n+\tint cap = 0;\n+\tint len = 0;\n+\tint i = 0;\n+\n+\tif (st->config.skip_name_check)\n+\t\treturn 0;\n+\n+\terr = reftable_block_source_from_file(&src, new_tab_name);\n+\tif (err < 0)\n+\t\tgoto done;\n+\n+\terr = reftable_new_reader(&rd, &src, new_tab_name);\n+\tif (err < 0)\n+\t\tgoto done;\n+\n+\terr = reftable_reader_seek_ref(rd, &it, \"\");\n+\tif (err > 0) {\n+\t\terr = 0;\n+\t\tgoto done;\n+\t}\n+\tif (err < 0)\n+\t\tgoto done;\n+\n+\twhile (1) {\n+\t\tstruct reftable_ref_record ref = { NULL };\n+\t\terr = reftable_iterator_next_ref(&it, &ref);\n+\t\tif (err > 0) {\n+\t\t\tbreak;\n+\t\t}\n+\t\tif (err < 0)\n+\t\t\tgoto done;\n+\n+\t\tif (len >= cap) {\n+\t\t\tcap = 2 * cap + 1;\n+\t\t\trefs = reftable_realloc(refs, cap * sizeof(refs));\n+\t\t}\n+\n+\t\trefs[len++] = ref;\n+\t}\n+\n+\treftable_table_from_merged_table(&tab, reftable_stack_merged_table(st));\n+\n+\terr = validate_ref_record_addition(tab, refs, len);\n+\n+done:\n+\tfor (i = 0; i < len; i++) {\n+\t\treftable_ref_record_clear(&refs[i]);\n+\t}\n+\n+\tfree(refs);\n+\treftable_iterator_destroy(&it);\n+\treturn err;\n+}\ndiff --git a/reftable/stack.h b/reftable/stack.h\nnew file mode 100644\nindex 0000000000..4e9557f08d\n--- /dev/null\n+++ b/reftable/stack.h\n@@ -0,0 +1,40 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#ifndef STACK_H\n+#define STACK_H\n+\n+#include \"reftable.h\"\n+#include \"system.h\"\n+\n+struct reftable_stack {\n+\tchar *list_file;\n+\tchar *reftable_dir;\n+\tint disable_auto_compact;\n+\n+\tstruct reftable_write_options config;\n+\n+\tstruct reftable_merged_table *merged;\n+\tstruct reftable_compaction_stats stats;\n+};\n+\n+int read_lines(const char *filename, char ***lines);\n+\n+struct segment {\n+\tint start, end;\n+\tint log;\n+\tuint64_t bytes;\n+};\n+\n+int fastlog2(uint64_t sz);\n+struct segment *sizes_to_segments(int *seglen, uint64_t *sizes, int n);\n+struct segment suggest_compaction_segment(uint64_t *sizes, int n);\n+\n+#endif\ndiff --git a/reftable/stack_test.c b/reftable/stack_test.c\nnew file mode 100644\nindex 0000000000..534463829c\n--- /dev/null\n+++ b/reftable/stack_test.c\n@@ -0,0 +1,788 @@\n+/*\n+\n+Use of this source code is governed by a BSD-style\n+*/\n+\n+#include \"stack.h\"\n+\n+#include \"system.h\"\n+\n+#include \"merged.h\"\n+#include \"basics.h\"\n+#include \"constants.h\"\n+#include \"record.h\"\n+#include \"reftable.h\"\n+#include \"test_framework.h\"\n+#include \"reftable-tests.h\"\n+\n+#include <sys/types.h>\n+#include <dirent.h>\n+\n+{\n+\tint fd = mkstemp(fn);\n+\tchar out = \"line1\\n\\nline2\\nline3\";\n+\tint n, err;\n+\tchar **names = NULL;\n+\tchar *want[] = { \"line1\", \"line2\", \"line3\" };\n+\tint i = 0;\n+\n+\tassert(fd > 0);\n+\tn = write(fd, out, strlen(out));\n+\tassert(n == strlen(out));\n+\terr = close(fd);\n+\tassert(err >= 0);\n+\n+\tassert_err(err);\n+\n+\tfor (i = 0; names[i] != NULL; i++) {\n+\t\tassert(0 == strcmp(want[i], names[i]));\n+\t}\n+\tfree_names(names);\n+\tremove(fn);\n+}\n+\n+static void test_parse_names(void)\n+{\n+\tchar buf[] = \"line\\n\";\n+\tchar **names = NULL;\n+\tparse_names(buf, strlen(buf), &names);\n+\n+\tassert(NULL != names);\n+\tassert(0 == strcmp(names, \"line\"));\n+\tassert(NULL == names);\n+\tfree_names(names);\n+}\n+\n+static void test_names_equal(void)\n+{\n+\tchar *a[] = { \"a\", \"b\", \"c\", NULL };\n+\tchar *b[] = { \"a\", \"b\", \"d\", NULL };\n+\tchar *c[] = { \"a\", \"b\", NULL };\n+\n+\tassert(names_equal(a, a));\n+\tassert(!names_equal(a, b));\n+\tassert(!names_equal(a, c));\n+}\n+\n+static int write_test_ref(struct reftable_writer *wr, void *arg)\n+{\n+\tstruct reftable_ref_record *ref = arg;\n+\treftable_writer_set_limits(wr, ref->update_index, ref->update_index);\n+}\n+\n+struct write_log_arg {\n+\tstruct reftable_log_record *log;\n+\tuint64_t update_index;\n+};\n+\n+static int write_test_log(struct reftable_writer *wr, void *arg)\n+{\n+\tstruct write_log_arg *wla = arg;\n+\n+\treftable_writer_set_limits(wr, wla->update_index, wla->update_index);\n+}\n+\n+{\n+\tchar dir = \"/tmp/stack_test.XXXXXX\";\n+\tstruct reftable_write_options cfg = { 0 };\n+\tstruct reftable_stack *st = NULL;\n+\tint err;\n+\tstruct reftable_ref_record ref = {\n+\t\t.update_index = 1,\n+\t\t.target = \"master\",\n+\t};\n+\tstruct reftable_ref_record dest = { NULL };\n+\n+\tassert(mkdtemp(dir));\n+\n+\terr = reftable_new_stack(&st, dir, cfg);\n+\tassert_err(err);\n+\n+\terr = reftable_stack_add(st, &write_test_ref, &ref);\n+\tassert_err(err);\n+\n+\terr = reftable_stack_read_ref(st, ref.refname, &dest);\n+\tassert_err(err);\n+\tassert(0 == strcmp(\"master\", dest.target));\n+\n+\treftable_ref_record_clear(&dest);\n+\treftable_stack_destroy(st);\n+\treftable_clear_dir(dir);\n+}\n+\n+static void test_reftable_stack_uptodate(void)\n+{\n+\tstruct reftable_write_options cfg = { 0 };\n+\tstruct reftable_stack *st1 = NULL;\n+\tstruct reftable_stack *st2 = NULL;\n+\tchar dir = \"/tmp/stack_test.XXXXXX\";\n+\tint err;\n+\tstruct reftable_ref_record ref1 = {\n+\t\t.update_index = 1,\n+\t\t.target = \"master\",\n+\t};\n+\tstruct reftable_ref_record ref2 = {\n+\t\t.refname = \"branch2\",\n+\t\t.update_index = 2,\n+\t\t.target = \"master\",\n+\t};\n+\n+\tassert(mkdtemp(dir));\n+\n+\terr = reftable_new_stack(&st1, dir, cfg);\n+\tassert_err(err);\n+\n+\terr = reftable_new_stack(&st2, dir, cfg);\n+\tassert_err(err);\n+\n+\terr = reftable_stack_add(st1, &write_test_ref, &ref1);\n+\tassert_err(err);\n+\n+\terr = reftable_stack_add(st2, &write_test_ref, &ref2);\n+\tassert(err == REFTABLE_LOCK_ERROR);\n+\n+\tassert_err(err);\n+\n+\terr = reftable_stack_add(st2, &write_test_ref, &ref2);\n+\tassert_err(err);\n+\treftable_stack_destroy(st1);\n+\treftable_stack_destroy(st2);\n+\treftable_clear_dir(dir);\n+}\n+\n+static void test_reftable_stack_transaction_api(void)\n+{\n+\tchar dir = \"/tmp/stack_test.XXXXXX\";\n+\tstruct reftable_write_options cfg = { 0 };\n+\tstruct reftable_stack *st = NULL;\n+\tint err;\n+\n+\tstruct reftable_ref_record ref = {\n+\t\t.update_index = 1,\n+\t\t.target = \"master\",\n+\t};\n+\tstruct reftable_ref_record dest = { NULL };\n+\n+\tassert(mkdtemp(dir));\n+\n+\terr = reftable_new_stack(&st, dir, cfg);\n+\tassert_err(err);\n+\n+\n+\tassert_err(err);\n+\n+\tassert_err(err);\n+\n+\tassert_err(err);\n+\n+\n+\terr = reftable_stack_read_ref(st, ref.refname, &dest);\n+\tassert_err(err);\n+\tassert(0 == strcmp(\"master\", dest.target));\n+\n+\treftable_ref_record_clear(&dest);\n+\treftable_stack_destroy(st);\n+\treftable_clear_dir(dir);\n+}\n+\n+static void test_reftable_stack_validate_refname(void)\n+{\n+\tstruct reftable_write_options cfg = { 0 };\n+\tstruct reftable_stack *st = NULL;\n+\tint err;\n+\tchar dir = \"/tmp/stack_test.XXXXXX\";\n+\tint i;\n+\tstruct reftable_ref_record ref = {\n+\t\t.refname = \"a/b\",\n+\t\t.update_index = 1,\n+\t\t.target = \"master\",\n+\t};\n+\tchar *additions[] = { \"a\", \"a/b/c\" };\n+\n+\tassert(mkdtemp(dir));\n+\terr = reftable_new_stack(&st, dir, cfg);\n+\tassert_err(err);\n+\n+\terr = reftable_stack_add(st, &write_test_ref, &ref);\n+\tassert_err(err);\n+\n+\tfor (i = 0; i < ARRAY_SIZE(additions); i++) {\n+\t\tstruct reftable_ref_record ref = {\n+\t\t\t.update_index = 1,\n+\t\t\t.target = \"master\",\n+\t\t};\n+\n+\t\terr = reftable_stack_add(st, &write_test_ref, &ref);\n+\t\tassert(err == REFTABLE_NAME_CONFLICT);\n+\t}\n+\n+\treftable_stack_destroy(st);\n+\treftable_clear_dir(dir);\n+}\n+\n+static int write_error(struct reftable_writer *wr, void *arg)\n+{\n+\treturn *((int *)arg);\n+}\n+\n+static void test_reftable_stack_update_index_check(void)\n+{\n+\tchar dir = \"/tmp/stack_test.XXXXXX\";\n+\tstruct reftable_write_options cfg = { 0 };\n+\tstruct reftable_stack *st = NULL;\n+\tint err;\n+\tstruct reftable_ref_record ref1 = {\n+\t\t.refname = \"name1\",\n+\t\t.update_index = 1,\n+\t\t.target = \"master\",\n+\t};\n+\tstruct reftable_ref_record ref2 = {\n+\t\t.refname = \"name2\",\n+\t\t.update_index = 1,\n+\t\t.target = \"master\",\n+\t};\n+\tassert(mkdtemp(dir));\n+\n+\terr = reftable_new_stack(&st, dir, cfg);\n+\tassert_err(err);\n+\n+\terr = reftable_stack_add(st, &write_test_ref, &ref1);\n+\tassert_err(err);\n+\n+\terr = reftable_stack_add(st, &write_test_ref, &ref2);\n+\tassert(err == REFTABLE_API_ERROR);\n+\treftable_stack_destroy(st);\n+\treftable_clear_dir(dir);\n+}\n+\n+static void test_reftable_stack_lock_failure(void)\n+{\n+\tchar dir = \"/tmp/stack_test.XXXXXX\";\n+\tstruct reftable_write_options cfg = { 0 };\n+\tstruct reftable_stack *st = NULL;\n+\tint err, i;\n+\tassert(mkdtemp(dir));\n+\n+\terr = reftable_new_stack(&st, dir, cfg);\n+\tassert_err(err);\n+\tfor (i = -1; i != REFTABLE_EMPTY_TABLE_ERROR; i--) {\n+\t\terr = reftable_stack_add(st, &write_error, &i);\n+\t\tassert(err == i);\n+\t}\n+\n+\treftable_stack_destroy(st);\n+\treftable_clear_dir(dir);\n+}\n+\n+{\n+\tint i = 0;\n+\tint err = 0;\n+\tstruct reftable_write_options cfg = {\n+\t\t.exact_log_message = 1,\n+\t};\n+\tstruct reftable_stack *st = NULL;\n+\tchar dir = \"/tmp/stack_test.XXXXXX\";\n+\tstruct reftable_ref_record refs = { { NULL } };\n+\tstruct reftable_log_record logs = { { NULL } };\n+\tint N = ARRAY_SIZE(refs);\n+\n+\tassert(mkdtemp(dir));\n+\n+\terr = reftable_new_stack(&st, dir, cfg);\n+\tassert_err(err);\n+\tst->disable_auto_compact = 1;\n+\n+\tfor (i = 0; i < N; i++) {\n+\t\tchar buf;\n+\t\tsnprintf(buf, sizeof(buf), \"branch%02d\", i);\n+\t\trefs[i].refname = xstrdup(buf);\n+\t\trefs[i].value = reftable_malloc(SHA1_SIZE);\n+\t\trefs[i].update_index = i + 1;\n+\t\tset_test_hash(refs[i].value, i);\n+\n+\t\tlogs[i].refname = xstrdup(buf);\n+\t\tlogs[i].update_index = N + i + 1;\n+\t\tlogs[i].new_hash = reftable_malloc(SHA1_SIZE);\n+\t\tlogs[i].email = xstrdup(\"identity@invalid\");\n+\t\tset_test_hash(logs[i].new_hash, i);\n+\t}\n+\n+\tfor (i = 0; i < N; i++) {\n+\t\tint err = reftable_stack_add(st, &write_test_ref, &refs[i]);\n+\t\tassert_err(err);\n+\t}\n+\n+\tfor (i = 0; i < N; i++) {\n+\t\tstruct write_log_arg arg = {\n+\t\t\t.log = &logs[i],\n+\t\t\t.update_index = reftable_stack_next_update_index(st),\n+\t\t};\n+\t\tint err = reftable_stack_add(st, &write_test_log, &arg);\n+\t\tassert_err(err);\n+\t}\n+\n+\terr = reftable_stack_compact_all(st, NULL);\n+\tassert_err(err);\n+\n+\tfor (i = 0; i < N; i++) {\n+\t\tstruct reftable_ref_record dest = { NULL };\n+\n+\t\tint err = reftable_stack_read_ref(st, refs[i].refname, &dest);\n+\t\tassert_err(err);\n+\t\tassert(reftable_ref_record_equal(&dest, refs + i, SHA1_SIZE));\n+\t\treftable_ref_record_clear(&dest);\n+\t}\n+\n+\tfor (i = 0; i < N; i++) {\n+\t\tstruct reftable_log_record dest = { NULL };\n+\t\tint err = reftable_stack_read_log(st, refs[i].refname, &dest);\n+\t\tassert_err(err);\n+\t\tassert(reftable_log_record_equal(&dest, logs + i, SHA1_SIZE));\n+\t\treftable_log_record_clear(&dest);\n+\t}\n+\n+\t/* cleanup */\n+\treftable_stack_destroy(st);\n+\tfor (i = 0; i < N; i++) {\n+\t\treftable_ref_record_clear(&refs[i]);\n+\t\treftable_log_record_clear(&logs[i]);\n+\t}\n+\treftable_clear_dir(dir);\n+}\n+\n+static void test_reftable_stack_log_normalize(void)\n+{\n+\tint err = 0;\n+\tstruct reftable_write_options cfg = {\n+\t\t0,\n+\t};\n+\tstruct reftable_stack *st = NULL;\n+\tchar dir = \"/tmp/stack_test.XXXXXX\";\n+\n+\tuint8_t h1[SHA1_SIZE] = { 0x01 }, h2[SHA1_SIZE] = { 0x02 };\n+\n+\tstruct reftable_log_record input = {\n+\t\t.refname = \"branch\",\n+\t\t.update_index = 1,\n+\t\t.new_hash = h1,\n+\t\t.old_hash = h2,\n+\t};\n+\tstruct reftable_log_record dest = {\n+\t\t.update_index = 0,\n+\t};\n+\tstruct write_log_arg arg = {\n+\t\t.log = &input,\n+\t\t.update_index = 1,\n+\t};\n+\n+\tassert(mkdtemp(dir));\n+\terr = reftable_new_stack(&st, dir, cfg);\n+\tassert_err(err);\n+\n+\tinput.message = \"one\\ntwo\";\n+\terr = reftable_stack_add(st, &write_test_log, &arg);\n+\tassert(err == REFTABLE_API_ERROR);\n+\n+\tinput.message = \"one\";\n+\terr = reftable_stack_add(st, &write_test_log, &arg);\n+\tassert_err(err);\n+\n+\terr = reftable_stack_read_log(st, input.refname, &dest);\n+\tassert_err(err);\n+\tassert(0 == strcmp(dest.message, \"one\\n\"));\n+\n+\tinput.message = \"two\\n\";\n+\targ.update_index = 2;\n+\terr = reftable_stack_add(st, &write_test_log, &arg);\n+\tassert_err(err);\n+\terr = reftable_stack_read_log(st, input.refname, &dest);\n+\tassert_err(err);\n+\tassert(0 == strcmp(dest.message, \"two\\n\"));\n+\n+\t/* cleanup */\n+\treftable_stack_destroy(st);\n+\treftable_log_record_clear(&dest);\n+\treftable_clear_dir(dir);\n+}\n+\n+static void test_reftable_stack_tombstone(void)\n+{\n+\tint i = 0;\n+\tchar dir = \"/tmp/stack_test.XXXXXX\";\n+\tstruct reftable_write_options cfg = { 0 };\n+\tstruct reftable_stack *st = NULL;\n+\tint err;\n+\tstruct reftable_ref_record refs = { { NULL } };\n+\tstruct reftable_log_record logs = { { NULL } };\n+\tint N = ARRAY_SIZE(refs);\n+\tstruct reftable_ref_record dest = { NULL };\n+\tstruct reftable_log_record log_dest = { NULL };\n+\n+\tassert(mkdtemp(dir));\n+\n+\terr = reftable_new_stack(&st, dir, cfg);\n+\tassert_err(err);\n+\n+\tfor (i = 0; i < N; i++) {\n+\t\tconst char *buf = \"branch\";\n+\t\trefs[i].refname = xstrdup(buf);\n+\t\trefs[i].update_index = i + 1;\n+\t\tif (i % 2 == 0) {\n+\t\t\trefs[i].value = reftable_malloc(SHA1_SIZE);\n+\t\t\tset_test_hash(refs[i].value, i);\n+\t\t}\n+\t\tlogs[i].refname = xstrdup(buf);\n+\t\t/* update_index is part of the key. */\n+\t\tlogs[i].update_index = 42;\n+\t\tif (i % 2 == 0) {\n+\t\t\tlogs[i].new_hash = reftable_malloc(SHA1_SIZE);\n+\t\t\tset_test_hash(logs[i].new_hash, i);\n+\t\t\tlogs[i].email = xstrdup(\"identity@invalid\");\n+\t\t}\n+\t}\n+\tfor (i = 0; i < N; i++) {\n+\t\tint err = reftable_stack_add(st, &write_test_ref, &refs[i]);\n+\t\tassert_err(err);\n+\t}\n+\tfor (i = 0; i < N; i++) {\n+\t\tstruct write_log_arg arg = {\n+\t\t\t.log = &logs[i],\n+\t\t\t.update_index = reftable_stack_next_update_index(st),\n+\t\t};\n+\t\tint err = reftable_stack_add(st, &write_test_log, &arg);\n+\t\tassert_err(err);\n+\t}\n+\n+\terr = reftable_stack_read_ref(st, \"branch\", &dest);\n+\tassert(err == 1);\n+\treftable_ref_record_clear(&dest);\n+\n+\terr = reftable_stack_read_log(st, \"branch\", &log_dest);\n+\tassert(err == 1);\n+\treftable_log_record_clear(&log_dest);\n+\n+\terr = reftable_stack_compact_all(st, NULL);\n+\tassert_err(err);\n+\n+\terr = reftable_stack_read_ref(st, \"branch\", &dest);\n+\tassert(err == 1);\n+\n+\terr = reftable_stack_read_log(st, \"branch\", &log_dest);\n+\tassert(err == 1);\n+\treftable_ref_record_clear(&dest);\n+\treftable_log_record_clear(&log_dest);\n+\n+\t/* cleanup */\n+\treftable_stack_destroy(st);\n+\tfor (i = 0; i < N; i++) {\n+\t\treftable_ref_record_clear(&refs[i]);\n+\t\treftable_log_record_clear(&logs[i]);\n+\t}\n+\treftable_clear_dir(dir);\n+}\n+\n+static void test_reftable_stack_hash_id(void)\n+{\n+\tchar dir = \"/tmp/stack_test.XXXXXX\";\n+\tstruct reftable_write_options cfg = { 0 };\n+\tstruct reftable_stack *st = NULL;\n+\tint err;\n+\n+\tstruct reftable_ref_record ref = {\n+\t\t.refname = \"master\",\n+\t\t.target = \"target\",\n+\t\t.update_index = 1,\n+\t};\n+\tstruct reftable_write_options cfg32 = { .hash_id = SHA256_ID };\n+\tstruct reftable_stack *st32 = NULL;\n+\tstruct reftable_write_options cfg_default = { 0 };\n+\tstruct reftable_stack *st_default = NULL;\n+\tstruct reftable_ref_record dest = { NULL };\n+\n+\tassert(mkdtemp(dir));\n+\terr = reftable_new_stack(&st, dir, cfg);\n+\tassert_err(err);\n+\n+\terr = reftable_stack_add(st, &write_test_ref, &ref);\n+\tassert_err(err);\n+\n+\t/* can't read it with the wrong hash ID. */\n+\terr = reftable_new_stack(&st32, dir, cfg32);\n+\tassert(err == REFTABLE_FORMAT_ERROR);\n+\n+\t/* check that we can read it back with default config too. */\n+\terr = reftable_new_stack(&st_default, dir, cfg_default);\n+\tassert_err(err);\n+\n+\terr = reftable_stack_read_ref(st_default, \"master\", &dest);\n+\tassert_err(err);\n+\n+\tassert(!strcmp(dest.target, ref.target));\n+\treftable_ref_record_clear(&dest);\n+\treftable_stack_destroy(st);\n+\treftable_stack_destroy(st_default);\n+\treftable_clear_dir(dir);\n+}\n+\n+static void test_log2(void)\n+{\n+\tassert(1 == fastlog2(3));\n+\tassert(2 == fastlog2(4));\n+\tassert(2 == fastlog2(5));\n+}\n+\n+static void test_sizes_to_segments(void)\n+{\n+\tuint64_t sizes[] = { 2, 3, 4, 5, 7, 9 };\n+\t/* .................0 1 2 3 4 5 */\n+\n+\tint seglen = 0;\n+\tstruct segment *segs =\n+\t\tsizes_to_segments(&seglen, sizes, ARRAY_SIZE(sizes));\n+\tassert(segs.log == 3);\n+\tassert(segs.start == 5);\n+\tassert(segs.end == 6);\n+\n+\tassert(segs.log == 2);\n+\tassert(segs.start == 2);\n+\tassert(segs.end == 5);\n+\treftable_free(segs);\n+}\n+\n+static void test_sizes_to_segments_empty(void)\n+{\n+\tuint64_t sizes;\n+\n+\tint seglen = 0;\n+\tstruct segment *segs =\n+\t\tsizes_to_segments(&seglen, sizes, ARRAY_SIZE(sizes));\n+\tassert(seglen == 0);\n+\treftable_free(segs);\n+}\n+\n+static void test_sizes_to_segments_all_equal(void)\n+{\n+\tuint64_t sizes[] = { 5, 5 };\n+\n+\tint seglen = 0;\n+\tstruct segment *segs =\n+\t\tsizes_to_segments(&seglen, sizes, ARRAY_SIZE(sizes));\n+\tassert(seglen == 1);\n+\tassert(segs.start == 0);\n+\tassert(segs.end == 2);\n+\treftable_free(segs);\n+}\n+\n+static void test_suggest_compaction_segment(void)\n+{\n+\tuint64_t sizes[] = { 128, 64, 17, 16, 9, 9, 9, 16, 16 };\n+\t/* .................0 1 2 3 4 5 6 */\n+\tstruct segment min =\n+\t\tsuggest_compaction_segment(sizes, ARRAY_SIZE(sizes));\n+\tassert(min.start == 2);\n+\tassert(min.end == 7);\n+}\n+\n+static void test_suggest_compaction_segment_nothing(void)\n+{\n+\tuint64_t sizes[] = { 64, 32, 16, 8, 4, 2 };\n+\tstruct segment result =\n+\t\tsuggest_compaction_segment(sizes, ARRAY_SIZE(sizes));\n+\tassert(result.start == result.end);\n+}\n+\n+static void test_reflog_expire(void)\n+{\n+\tchar dir = \"/tmp/stack.test_reflog_expire.XXXXXX\";\n+\tstruct reftable_write_options cfg = { 0 };\n+\tstruct reftable_stack *st = NULL;\n+\tstruct reftable_log_record logs = { { NULL } };\n+\tint N = ARRAY_SIZE(logs) - 1;\n+\tint i = 0;\n+\tint err;\n+\tstruct reftable_log_expiry_config expiry = {\n+\t\t.time = 10,\n+\t};\n+\tstruct reftable_log_record log = { NULL };\n+\n+\tassert(mkdtemp(dir));\n+\n+\terr = reftable_new_stack(&st, dir, cfg);\n+\tassert_err(err);\n+\n+\tfor (i = 1; i <= N; i++) {\n+\t\tchar buf;\n+\t\tsnprintf(buf, sizeof(buf), \"branch%02d\", i);\n+\n+\t\tlogs[i].refname = xstrdup(buf);\n+\t\tlogs[i].update_index = i;\n+\t\tlogs[i].time = i;\n+\t\tlogs[i].new_hash = reftable_malloc(SHA1_SIZE);\n+\t\tlogs[i].email = xstrdup(\"identity@invalid\");\n+\t\tset_test_hash(logs[i].new_hash, i);\n+\t}\n+\n+\tfor (i = 1; i <= N; i++) {\n+\t\tstruct write_log_arg arg = {\n+\t\t\t.log = &logs[i],\n+\t\t\t.update_index = reftable_stack_next_update_index(st),\n+\t\t};\n+\t\tint err = reftable_stack_add(st, &write_test_log, &arg);\n+\t\tassert_err(err);\n+\t}\n+\n+\terr = reftable_stack_compact_all(st, NULL);\n+\tassert_err(err);\n+\n+\terr = reftable_stack_compact_all(st, &expiry);\n+\tassert_err(err);\n+\n+\terr = reftable_stack_read_log(st, logs.refname, &log);\n+\tassert(err == 1);\n+\n+\terr = reftable_stack_read_log(st, logs.refname, &log);\n+\tassert_err(err);\n+\n+\texpiry.min_update_index = 15;\n+\terr = reftable_stack_compact_all(st, &expiry);\n+\tassert_err(err);\n+\n+\terr = reftable_stack_read_log(st, logs.refname, &log);\n+\tassert(err == 1);\n+\n+\terr = reftable_stack_read_log(st, logs.refname, &log);\n+\tassert_err(err);\n+\n+\t/* cleanup */\n+\treftable_stack_destroy(st);\n+\tfor (i = 0; i <= N; i++) {\n+\t\treftable_log_record_clear(&logs[i]);\n+\t}\n+\treftable_clear_dir(dir);\n+\treftable_log_record_clear(&log);\n+}\n+\n+static int write_nothing(struct reftable_writer *wr, void *arg)\n+{\n+\treftable_writer_set_limits(wr, 1, 1);\n+\treturn 0;\n+}\n+\n+{\n+\tstruct reftable_write_options cfg = { 0 };\n+\tstruct reftable_stack *st = NULL;\n+\tint err;\n+\tchar dir = \"/tmp/stack_test.XXXXXX\";\n+\tstruct reftable_stack *st2 = NULL;\n+\n+\tassert(mkdtemp(dir));\n+\n+\terr = reftable_new_stack(&st, dir, cfg);\n+\tassert_err(err);\n+\n+\terr = reftable_stack_add(st, &write_nothing, NULL);\n+\tassert_err(err);\n+\n+\terr = reftable_new_stack(&st2, dir, cfg);\n+\tassert_err(err);\n+\treftable_clear_dir(dir);\n+\treftable_stack_destroy(st);\n+\treftable_stack_destroy(st2);\n+}\n+\n+static void test_reftable_stack_auto_compaction(void)\n+{\n+\tstruct reftable_write_options cfg = { 0 };\n+\tstruct reftable_stack *st = NULL;\n+\tchar dir = \"/tmp/stack_test.XXXXXX\";\n+\tint err, i;\n+\tint N = 100;\n+\tassert(mkdtemp(dir));\n+\n+\terr = reftable_new_stack(&st, dir, cfg);\n+\tassert_err(err);\n+\n+\tfor (i = 0; i < N; i++) {\n+\t\tchar name;\n+\t\tstruct reftable_ref_record ref = {\n+\t\t\t.refname = name,\n+\t\t\t.update_index = reftable_stack_next_update_index(st),\n+\t\t\t.target = \"master\",\n+\t\t};\n+\t\tsnprintf(name, sizeof(name), \"branch%04d\", i);\n+\n+\t\terr = reftable_stack_add(st, &write_test_ref, &ref);\n+\t\tassert_err(err);\n+\n+\t\tassert(i < 3 || st->merged->stack_len < 2 * fastlog2(i));\n+\t}\n+\n+\tassert(reftable_stack_compaction_stats(st)->entries_written <\n+\t (uint64_t)(N * fastlog2(N)));\n+\n+\treftable_stack_destroy(st);\n+\treftable_clear_dir(dir);\n+}\n+\n+int stack_test_main(int argc, const char *argv[])\n+{\n+\t\t &test_reftable_stack_uptodate);\n+\t\t &test_reftable_stack_transaction_api);\n+\t\t &test_reftable_stack_hash_id);\n+\t\t &test_sizes_to_segments_all_equal);\n+\t\t &test_reftable_stack_auto_compaction);\n+\t\t &test_reftable_stack_validate_refname);\n+\t\t &test_reftable_stack_update_index_check);\n+\t\t &test_reftable_stack_lock_failure);\n+\t\t &test_reftable_stack_log_normalize);\n+\t\t &test_reftable_stack_tombstone);\n+\t\t &test_suggest_compaction_segment);\n+\t\t &test_suggest_compaction_segment_nothing);\n+\t\t &test_sizes_to_segments_empty);\n+\treturn test_main(argc, argv);\n+}\ndiff --git a/reftable/update.sh b/reftable/update.sh\nnew file mode 100755\n--- /dev/null\n+++ b/reftable/update.sh\n@@ -0,0 +1,22 @@\n+#!/bin/sh\n+\n+set -eu\n+\n+# Override this to import from somewhere else, say \"../reftable\".\n+SRC=\\${SRC:-origin}\n+BRANCH=\\${BRANCH:-master}\n+\n+((git --git-dir reftable-repo/.git fetch -f \\${SRC} \\${BRANCH}:import && cd reftable-repo && git checkout -f \\$(git rev-parse import) ) ||\n+\n+cp reftable-repo/c/*.[ch] reftable/\n+cp reftable-repo/c/include/*.[ch] reftable/\n+\n+git --git-dir reftable-repo/.git show --no-patch --format=oneline HEAD \\\n+ > reftable/VERSION\n+\n+mv reftable/system.h reftable/system.h~\n+sed 's|if REFTABLE_IN_GITCORE|if 1 /* REFTABLE_IN_GITCORE */|' < reftable/system.h~ > reftable/system.h\n+\ndiff --git a/t/helper/test-reftable.c b/t/helper/test-reftable.c\nindex 2273fdfe39..def8883439 100644\n--- a/t/helper/test-reftable.c\n+++ b/t/helper/test-reftable.c\n@@ -4,9 +4,12 @@\nint cmd__reftable(int argc, const char **argv)\n{\nblock_test_main(argc, argv);\n+\tmerged_test_main(argc, argv);\nrecord_test_main(argc, argv);\n+\trefname_test_main(argc, argv);\nreftable_test_main(argc, argv);\nstrbuf_test_main(argc, argv);\n+\tstack_test_main(argc, argv);\ntree_test_main(argc, argv);\nreturn 0;\n}\n--\n\n• ```* Re: [PATCH v2 12/13] reftable: rest of library\n2020-10-01 16:11 ` [PATCH v2 12/13] reftable: rest of library Han-Wen Nienhuys via GitGitGadget\n@ 2020-10-02 13:57 ` Johannes Schindelin\n2020-10-02 17:08 ` Junio C Hamano\nFrom: Johannes Schindelin @ 2020-10-02 13:57 UTC (permalink / raw)\nCc: git, Han-Wen Nienhuys, Jeff King, Han-Wen Nienhuys, Han-Wen Nienhuys\n\nHi Han-Wen,\n\nOn Thu, 1 Oct 2020, Han-Wen Nienhuys via GitGitGadget wrote:\n\n>\n> This will be further split up once preceding commits have passed review.\n\nBefore you further split it up, I encourage you to include these patches\nwithout which the CI builds will continue to fail (Junio, could I ask you\nto either cherry-pick them from https://github.com/git-for-windows/git's\nshears/seen branch, or apply them from the mbox?):\n\n-- snipsnap --\nFrom e485e006f34922439f2e971a1c5c38b8ca56c011 Mon Sep 17 00:00:00 2001\nFrom: Johannes Schindelin <[email protected]>\nDate: Wed, 30 Sep 2020 14:46:59 +0200\nSubject: [PATCH 1/3] fixup??? reftable: rest of library\n\nstruct abc x = {}\n\nis a GNUism.\n\nSigned-off-by: Johannes Schindelin <[email protected]>\n---\nreftable/dump.c | 4 ++--\n1 file changed, 2 insertions(+), 2 deletions(-)\n\ndiff --git a/reftable/dump.c b/reftable/dump.c\nindex ed09f2e2f94..233f0434e39 100644\n--- a/reftable/dump.c\n+++ b/reftable/dump.c\n@@ -75,7 +75,7 @@ static int dump_table(const char *tablename)\nstatic int compact_stack(const char *stackdir)\n{\nstruct reftable_stack *stack = NULL;\n-\tstruct reftable_write_options cfg = {};\n+\tstruct reftable_write_options cfg = { 0 };\n\nint err = reftable_new_stack(&stack, stackdir, cfg);\nif (err < 0)\n@@ -94,7 +94,7 @@ static int compact_stack(const char *stackdir)\nstatic int dump_stack(const char *stackdir)\n{\nstruct reftable_stack *stack = NULL;\n-\tstruct reftable_write_options cfg = {};\n+\tstruct reftable_write_options cfg = { 0 };\nstruct reftable_iterator it = { NULL };\nstruct reftable_ref_record ref = { NULL };\nstruct reftable_log_record log = { NULL };\n--\n2.28.0.windows.1.18.g5300e52e185\n\nFrom d5faa818a1bc00016e310d27602551127db620fb Mon Sep 17 00:00:00 2001\nFrom: Johannes Schindelin <[email protected]>\nDate: Wed, 30 Sep 2020 14:55:28 +0200\nSubject: [PATCH 2/3] fixup??? reftable: rest of library\n\n0-sized arrays are actually not portable.\n\nSigned-off-by: Johannes Schindelin <[email protected]>\n---\nreftable/stack_test.c | 4 ++--\n1 file changed, 2 insertions(+), 2 deletions(-)\n\ndiff --git a/reftable/stack_test.c b/reftable/stack_test.c\nindex 534463829cb..e863cc3c0a2 100644\n--- a/reftable/stack_test.c\n+++ b/reftable/stack_test.c\n@@ -572,11 +572,11 @@ static void test_sizes_to_segments(void)\n\nstatic void test_sizes_to_segments_empty(void)\n{\n-\tuint64_t sizes;\n+\tuint64_t sizes;\n\nint seglen = 0;\nstruct segment *segs =\n-\t\tsizes_to_segments(&seglen, sizes, ARRAY_SIZE(sizes));\n+\t\tsizes_to_segments(&seglen, sizes, 0);\nassert(seglen == 0);\nreftable_free(segs);\n}\n--\n2.28.0.windows.1.18.g5300e52e185\n\nFrom d446e1a7354c676d60114b50ba96a6ea083441ae Mon Sep 17 00:00:00 2001\nFrom: Johannes Schindelin <[email protected]>\nDate: Wed, 30 Sep 2020 15:19:28 +0200\nSubject: [PATCH 3/3] fixup??? reftable: rest of library\n\nAvoid using `getopt()`: it might be POSIX, but Git's audience is much\nlarger than POSIX. MSVC, for example, does not support `getopt()`.\n\nSigned-off-by: Johannes Schindelin <[email protected]>\n---\nreftable/dump.c | 32 +++++++++++++-------------------\n1 file changed, 13 insertions(+), 19 deletions(-)\n\ndiff --git a/reftable/dump.c b/reftable/dump.c\nindex 233f0434e39..b63c9fe9e81 100644\n--- a/reftable/dump.c\n+++ b/reftable/dump.c\n@@ -160,40 +160,34 @@ static void print_help(void)\nint reftable_dump_main(int argc, char *const *argv)\n{\nint err = 0;\n-\tint opt;\nint opt_dump_table = 0;\nint opt_dump_stack = 0;\nint opt_compact = 0;\n-\tconst char *arg = NULL;\n-\twhile ((opt = getopt(argc, argv, \"2chts\")) != -1) {\n-\t\tswitch (opt) {\n-\t\tcase '2':\n-\t\t\thash_id = 0x73323536;\n+\tconst char *arg = NULL, *argv0 = argv;\n+\n+\tfor (; argc > 1; argv++, argc--)\n+\t\tif (*argv != '-')\nbreak;\n-\t\tcase 't':\n+\t\telse if (!strcmp(\"-2\", argv))\n+\t\t\thash_id = 0x73323536;\n+\t\telse if (!strcmp(\"-t\", argv))\nopt_dump_table = 1;\n-\t\t\tbreak;\n-\t\tcase 's':\n+\t\telse if (!strcmp(\"-s\", argv))\nopt_dump_stack = 1;\n-\t\t\tbreak;\n-\t\tcase 'c':\n+\t\telse if (!strcmp(\"-c\", argv))\nopt_compact = 1;\n-\t\t\tbreak;\n-\t\tcase '?':\n-\t\tcase 'h':\n+\t\telse if (!strcmp(\"-?\", argv) || !strcmp(\"-h\", argv)) {\nprint_help();\nreturn 2;\n-\t\t\tbreak;\n}\n-\t}\n\n-\tif (argv[optind] == NULL) {\n+\tif (argc != 2) {\nfprintf(stderr, \"need argument\\n\");\nprint_help();\nreturn 2;\n}\n\n-\targ = argv[optind];\n+\targ = argv;\n\nif (opt_dump_table) {\nerr = dump_table(arg);\n@@ -204,7 +198,7 @@ int reftable_dump_main(int argc, char *const *argv)\n}\n\nif (err < 0) {\n-\t\tfprintf(stderr, \"%s: %s: %s\\n\", argv, arg,\n+\t\tfprintf(stderr, \"%s: %s: %s\\n\", argv0, arg,\nreftable_error_str(err));\nreturn 1;\n}\n--\n2.28.0.windows.1.18.g5300e52e185\n\n• ```* Re: [PATCH v2 12/13] reftable: rest of library\n2020-10-02 13:57 ` Johannes Schindelin\n@ 2020-10-02 17:08 ` Junio C Hamano\n2020-10-04 18:39 ` Johannes Schindelin\nFrom: Junio C Hamano @ 2020-10-02 17:08 UTC (permalink / raw)\nTo: Johannes Schindelin\nCc: Han-Wen Nienhuys via GitGitGadget, git, Han-Wen Nienhuys,\nJeff King, Han-Wen Nienhuys\n\nJohannes Schindelin <[email protected]> writes:\n\n> Subject: [PATCH 1/3] fixup??? reftable: rest of library\n\nThis is unambiguously good.\n\n> Subject: [PATCH 2/3] fixup??? reftable: rest of library\n>\n> 0-sized arrays are actually not portable.\n> ...\n> static void test_sizes_to_segments_empty(void)\n> {\n> -\tuint64_t sizes;\n> +\tuint64_t sizes;\n>\n> \tint seglen = 0;\n> \tstruct segment *segs =\n> -\t\tsizes_to_segments(&seglen, sizes, ARRAY_SIZE(sizes));\n> +\t\tsizes_to_segments(&seglen, sizes, 0);\n> \tassert(seglen == 0);\n> \treftable_free(segs);\n\nQuestion to Han-Wen.\n\nIt is unclear what this test wants to test. Do we even need sizes[]\narray if we know we are passing a hardcoded 0? IOW, I would\nunderstand if the test were\n\nsizes_to_segments(&seglen, NULL, 0);\n\nto ensure that sizes_to_segments do not even attempt to look at sizes[]\narray when the number of elements is 0.\n\n> Subject: [PATCH 3/3] fixup??? reftable: rest of library\n>\n> Avoid using `getopt()`: it might be POSIX, but Git's audience is much\n> larger than POSIX. MSVC, for example, does not support `getopt()`.\n\nEither that, or we could use parse-options(). I do not care either\nway, as this seems to be purely for debugging?\n\n• ```* Re: [PATCH v2 12/13] reftable: rest of library\n2020-10-02 17:08 ` Junio C Hamano\n@ 2020-10-04 18:39 ` Johannes Schindelin\n0 siblings, 0 replies; 251+ messages in thread\nFrom: Johannes Schindelin @ 2020-10-04 18:39 UTC (permalink / raw)\nTo: Junio C Hamano\nCc: Han-Wen Nienhuys via GitGitGadget, git, Han-Wen Nienhuys,\nJeff King, Han-Wen Nienhuys\n\nHi Junio,\n\nOn Fri, 2 Oct 2020, Junio C Hamano wrote:\n\n> Johannes Schindelin <[email protected]> writes:\n>\n> > Subject: [PATCH 3/3] fixup??? reftable: rest of library\n> >\n> > Avoid using `getopt()`: it might be POSIX, but Git's audience is much\n> > larger than POSIX. MSVC, for example, does not support `getopt()`.\n>\n> Either that, or we could use parse-options(). I do not care either\n> way, as this seems to be purely for debugging?\n\nI actually wanted to use `parse_options()`, but due to the way `reftable/`\ninsists on being completely separate from `libgit.a`, it is not really\ntrivial, as `#include \"parse-options.h\"` fails (because\n`git-compat-util.h` was not included, and IIRC including _that_ resulted\nin more compile errors, at which stage I opted for a more minimal\nsolution).\n\nSo yeah, I would strongly expect `reftable/` to become considerably\nsimpler once it starts using `libgit.a`'s goodies.\n\nCiao,\nDscho\n\n• ```* [PATCH v2 13/13] reftable: \"test-tool dump-reftable\" command." ]

[ null ]

[ "", null, "machine-learning\nnumpy\npython\nregression", null, "6", null, "0", null, "``````>> count_vectorizer = CountVectorizer(min_n=1, max_n=1)\n>> term_freq = count_vectorizer.fit_transform(texts)\n>> transformer = TfidfTransformer()\n>> X = transformer.fit_transform(term_freq)\n>> print X.shape\n\n(26, 6323)\n``````\n\n``````using ngrams (n=1):\nhuman machine points-off %error\n8.67 8.27 0.40 1.98\n8.00 7.33 0.67 3.34\n... ... ... ...\n5.00 6.61 1.61 8.06\n9.00 7.50 1.50 7.50\nmean: 7.59 7.64 1.29 6.47\nstd : 1.94 0.56 1.38 6.91\n``````\n\n``````using ngrams (n=300):\nhuman machine points-off %error\n8.67 7.55 1.12 5.60\n8.00 7.57 0.43 2.13\n... ... ... ...\nmean: 7.59 7.59 1.52 7.59\nstd : 1.94 0.08 1.32 6.61\n``````\n\nStack Overflow", null, "收藏", null, "评论", null, "[机器学习会议有时会像比赛一样进行，在他们将最终模型交付给组织者之前不会将测试集提供给研究人员。同时，他们可以随意使用训练集，例如通过使用交叉验证测试模型。 Kaggle做类似的事情。]", null, "收藏", null, "评论\n\n•", null, "社区规范\n•", null, "提出问题\n•", null, "进行投票\n•", null, "个人资料\n•", null, "优化问题\n•", null, "回答问题", null, "关于我们", null, "常见问题", null, "内容许可", null, "联系我们" ]

[ null, "https://static.askgo.cn/prod/client/img/change.a22960f.png", null, "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAYAAAEFCu8CAAAABGdBTUEAALGPC/xhBQAAADhlWElmTU0AKgAAAAgAAYdpAAQAAAABAAAAGgAAAAAAAqACAAQAAAABAAAAHKADAAQAAAABAAAAHAAAAABHddaYAAADNElEQVRIDeWVWWsUQRCAV4134n3EkyWEKGLUeGuCGo94oL824JNPioiKGCIEzwhRIx5J1Hgbo9+3mRp6x1nxTcSCj66urp2uqq7urVQKMiuZn0Vv0jAHVsN7WAG5bMm1VOlkciE11OlddbPEdVGiVw5mXg2/c7rwmWbmCwq28ulhzOuzpaOMc8OtJxTG2LcpbHV5Y4z9L8xm0p15+WlFmzIxM1Qqe0PJxvh8bjag/ZAHkx5E7oViyTdmjn5+CCahVM5h3Va6MmN0N0NpCR9POo2tWNF5rJ8PZ8aV0Gu2xn4DQk6Fko1fGacS2xh6c+R4KFu8mTlUGTsz/RPjpUxfyHgS+uOHmb1iT1mUuzAM32EV7AFzvAjT8BekGKohWDXPcRmY3wg8goYSV6OuQ/Cugsf1y53CVtvFxWhGbUXZh6EvjB6+4Z6AfvgBynHYDoZsuO9gFNZBKzyDigduXiH5xckMvYxLYpHRyGq1UQnxEhevimtnwoFxOXSV5VRmixT8vb07pZM5GLvik7YW7JIQC3IlJoxW/Y5z483j1oB4xbSJLRdiPXbExHEp6JTupD2VY0wsVE1q1cl0f2QRJuE2vAVtHdAG9+Ee1CT9Ydi8yDq2wBfw/F7CPyplKUYqrm2AdjDdENMW1y1HehCvmT+EV1AqZRvaif5P2epvYBA8mD8R7413yifNfrwGHyCXdEOdjoAd7BP3AIpie5n1YvCpM5Cn8BlS8QJ469fAR7gM32DmMjJugl1gRleh0btp9n7MG2Rg/kH6QsyHsiD16QED9J/ihc+Nj3YXWH83S++rFegDI41MLJWPu38nZuir6W93gxUYhRD9HoOvzlaYMFozsyTWuyhmYPR++HcyzuIEtEJ6TPGbWyiWtNMNB8Bu8/yKMobBM6iCZ9xIfKAst1VIK6S/AVhWu3kgoomy1h0wDiE7UTaDlRgGM/Y4rEAbROBP0FOxlN1gx3tc47Eheq10Zmm2IzAIxWgtr2WzCVxzY5+hKUjFZnGjZtDHzTzP0np7yQ9A3KUh9OdQ3BxTnZhFFTrA7O3462Bz5ZJmmBsTxZK1g2eUihlZRgmZRvEM7VqvzX8qPwHHMZF3zTMhZQAAAABJRU5ErkJggg==", null, "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAYAAAEFCu8CAAAABGdBTUEAALGPC/xhBQAAADhlWElmTU0AKgAAAAgAAYdpAAQAAAABAAAAGgAAAAAAAqACAAQAAAABAAAAHKADAAQAAAABAAAAHAAAAABHddaYAAAC60lEQVRIDcWW109VQRCHUURs116xRBRrggW7Bnt70L/XJxOVFyFifJXExAjYEo0dW9TvO5w5nHvK5Wo0TvK7U3d3dnZ2z+3oqKHrqf1I0T8nDIcQroYi3xLKuVRI5jiYKo25CF2gD8xLjRlrIMWSibE/czUL80NdFEIrfqbOeT51ZLsxIzPbA+6kzmspvyk/lSpFlmV9peBJHG5aejvNmn/D+Q6z0eaQTdccOqOZsUEbwYUZc2spBkXUUoQ4pbAlXON+EKk1OSsUTyFL+SRK5ayFgTGos2CfmanoQF8IToQ9n95ujKPhgA8AU1qS2qbgq1O5xC5i2VayTh/Faew7wlfKNRzw6LKWh5yLT0TP7hHYBzyetsjAKHcDubLa+eLErGcRbqfKe7jFKa1q/y0Ae0FPLsD+DBpCiHvxCXkCPNRpWqbUDrmy+x6MVD+3M4qYn2AZeGV8XBc7Yzay2sfzQaYwW8re6AMxKFI1BZf/Fo4K7iP1IOwxUH0VaLVXJ862kx/o4KAGgqnb6EHjCJtCsTB5clXv5ldwA/QCJ5gE2rpBiXZhGQTFyQzsA5cUgkqtFI4avgH74YLvHvqzgq1W7az1lB2bMVmrp+AWGAPW0B3awvn2Rq2mdhf0WfaT505Gc1Op++r6oHwEXsKWVLegdidaC7YDd/EcWL4iuWOvi4suBvalXfUd/ABN5Bk66VEQ52nQB2CJhC+c3K5pRS5kkpY5z2NTXqIRF7kMusEQeAP+Ba1kUr/eUy7YBXwIlgN3Mwy+gL9Bvp3O7a5fg+EoI3KHWx8A64GfpLvA0v4J+Xr7LXRBG+s+SM4zvyC2hLQdA2vACHgBfodM2H+BL4HjPbuMqt4oA1YAm+R3F3Niu9nX1SNqWgy98o9JD3afqScG1JAlE3U0gcOuXVcMqHr/fFEkBwV56DuByUjxfbDhpEkwBuLM1XuBr3ZTlarOcCtB/SBPltc/EI+BFzpPJu3kPhCRQPj9MI2H8l/4L365bnfKEyaeAAAAAElFTkSuQmCC", null, "https://static.askgo.cn/prod/client/img/change.a22960f.png", null, "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAAGXcA1uAAAABGdBTUEAALGPC/xhBQAAADhlWElmTU0AKgAAAAgAAYdpAAQAAAABAAAAGgAAAAAAAqACAAQAAAABAAAAGKADAAQAAAABAAAAGAAAAADB/VeXAAACKUlEQVRIDc2VO0hcQRSG10eRRkQFidFNtLCKRFFIWEQIBCGFlha+MEQIgdjZqahY2Ri18LFFujS29kKKIFgEJBAbsVITFdQmIEpM8v27M9e519G7gqAHvj1n/jn3zuvM3UTCsTwTD+EfObonHDZal6fvQiq5CLPRXER457YXaeRDSHQTMnGBo8wTH8KO1YoJ0qZRiV+wHe5T0ur1o8HOYUYNY0XyhabxG98MbfAHvoLXHqOOeXs84jO0h0bXmr027VXDYk+4mV1QsGSnU1vxxra1amt/Cb6YRhI/YOJdfKmJ79CNMnZ1ruM/J1FzVlHkZHbvy8luiD5h70IHHS9N5yR+28S6I0/gF8zCMWSs2wbX+I9u33saKomrTOuJlm+iD1EHFjWdfnDAQYC4BXbu7kOnNFQFGXMfSFkR/wHsaGuOHlwUabrsWot2ZQT0gmHQBb3HZg86boramwk4g3/wAFSf53ArppfpWK31EoxD7AQvFYd5g3R9xp/CW9iHT2DtO0EttIPKQAOdQFAOxBlzZzCIUgWroHoSexC3Ddo+XTR9ipLQAj9hCkJlpE9PDfyADcjVNGtNRGg1raDJeU2z6QfdrUZvhl9Urp7Rs3pHrOkypKEsNjP78VJutS/3qtFSJG9CLrfsyOS+8A1g//OifUpeNmIFXtXSBAdG06F+A+Vo79fhNSxByNwqcjvqaHSCDnAF9CerP1vXNDlVzCvQTnyGmxQH6bdg/wGJY1TxAxwNlgAAAABJRU5ErkJggg==", null, "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA8AAAAPCAYAAAFM0aXcAAAABGdBTUEAALGPC/xhBQAAADhlWElmTU0AKgAAAAgAAYdpAAQAAAABAAAAGgAAAAAAAqACAAQAAAABAAAAD6ADAAQAAAABAAAADwAAAAAk/vkzAAAAn0lEQVQoFWNgQAPyKHweFB6UI45NEFPMFFOIgaERKJiATYJ4MZCbapGUywLZsUh8OJMPyEqA8+jDYMFijRpMrB/IYIVxgPRiJDaYORFIsgHxEnQJGL8PxhiqNDOSw7uBbDMgPg7E/5DEkZkyQM4UqPxNZAkQG5QSJgBxPRAjh6sckA8K23gghgNGOAuVwQvktgLxVyAGadwDxPOBeJAAAPxmEEX3ECWMAAAAAElFTkSuQmCC", null, "https://static.askgo.cn/prod/client/img/change.a22960f.png", null, "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAAGXcA1uAAAABGdBTUEAALGPC/xhBQAAADhlWElmTU0AKgAAAAgAAYdpAAQAAAABAAAAGgAAAAAAAqACAAQAAAABAAAAGKADAAQAAAABAAAAGAAAAADB/VeXAAACKUlEQVRIDc2VO0hcQRSG10eRRkQFidFNtLCKRFFIWEQIBCGFlha+MEQIgdjZqahY2Ri18LFFujS29kKKIFgEJBAbsVITFdQmIEpM8v27M9e519G7gqAHvj1n/jn3zuvM3UTCsTwTD+EfObonHDZal6fvQiq5CLPRXER457YXaeRDSHQTMnGBo8wTH8KO1YoJ0qZRiV+wHe5T0ur1o8HOYUYNY0XyhabxG98MbfAHvoLXHqOOeXs84jO0h0bXmr027VXDYk+4mV1QsGSnU1vxxra1amt/Cb6YRhI/YOJdfKmJ79CNMnZ1ruM/J1FzVlHkZHbvy8luiD5h70IHHS9N5yR+28S6I0/gF8zCMWSs2wbX+I9u33saKomrTOuJlm+iD1EHFjWdfnDAQYC4BXbu7kOnNFQFGXMfSFkR/wHsaGuOHlwUabrsWot2ZQT0gmHQBb3HZg86boramwk4g3/wAFSf53ArppfpWK31EoxD7AQvFYd5g3R9xp/CW9iHT2DtO0EttIPKQAOdQFAOxBlzZzCIUgWroHoSexC3Ddo+XTR9ipLQAj9hCkJlpE9PDfyADcjVNGtNRGg1raDJeU2z6QfdrUZvhl9Urp7Rs3pHrOkypKEsNjP78VJutS/3qtFSJG9CLrfsyOS+8A1g//OifUpeNmIFXtXSBAdG06F+A+Vo79fhNSxByNwqcjvqaHSCDnAF9CerP1vXNDlVzCvQTnyGmxQH6bdg/wGJY1TxAxwNlgAAAABJRU5ErkJggg==", null, "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA8AAAAPCAYAAAFM0aXcAAAABGdBTUEAALGPC/xhBQAAADhlWElmTU0AKgAAAAgAAYdpAAQAAAABAAAAGgAAAAAAAqACAAQAAAABAAAAD6ADAAQAAAABAAAADwAAAAAk/vkzAAAAn0lEQVQoFWNgQAPyKHweFB6UI45NEFPMFFOIgaERKJiATYJ4MZCbapGUywLZsUh8OJMPyEqA8+jDYMFijRpMrB/IYIVxgPRiJDaYORFIsgHxEnQJGL8PxhiqNDOSw7uBbDMgPg7E/5DEkZkyQM4UqPxNZAkQG5QSJgBxPRAjh6sckA8K23gghgNGOAuVwQvktgLxVyAGadwDxPOBeJAAAPxmEEX3ECWMAAAAAElFTkSuQmCC", null, "https://static.askgo.cn/prod/client/img/sq.98426a6.png", null, "https://static.askgo.cn/prod/client/img/tw.9c3aff8.png", null, "https://static.askgo.cn/prod/client/img/tp.94ecfa8.png", null, "https://static.askgo.cn/prod/client/img/zl.a5e9c8a.png", null, "https://static.askgo.cn/prod/client/img/yh.a2448e9.png", null, "https://static.askgo.cn/prod/client/img/wt.8285248.png", null, "https://static.askgo.cn/prod/client/img/gywm.70348ff.png", null, "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAYAAAEFCu8CAAAABGdBTUEAALGPC/xhBQAAADhlWElmTU0AKgAAAAgAAYdpAAQAAAABAAAAGgAAAAAAAqACAAQAAAABAAAAHKADAAQAAAABAAAAHAAAAABHddaYAAADRklEQVRIDc1WPYhTQRB++bkTJcdpoRxcERAbMd4hRlAR/D1L7XIgmj8LEbUTKwXlCn8OC0HQ4syPmiaNhkCaO685RYvYJAgWFhZXRExi1BSeMYnfvLwJu3v7EpPKhcfMfjvfzM7s7HvPMKwRi8WWWTcw+dmdsJJIJE6yvl6CUpRQAG0TiMfjm0lxWsurluyIrhmmoq4arSSTySkJpAn2NCeCDp5gYW+r1XrrcDi2RSKRGuHmBuBm0ul0uqPR6Gi73f7IBDcpYHyC9UbSwTxCUjt67bSTtUXjpNnLEisk1cUT4mI3FQZRx1fY8THM/+B5g+cwrSGb2XA4nCadhplJRzVLukgkpCs5hLPdyLYAOz0RhBl2Iko4WxHnpEue1UWUKgPslMvlmg6FQhSx/8D2HtrWuD99CAuK1iuiNkcQHqBPziFeA/I+juGeGlsi5vP5kUKh8JuMQKAbsxUVnYDeRuNJDSEREYlILhyLi8g00un0eL1er4F8E+RbHXR9W4243W6zU9ggEAh8t/QrjJGUwhMQDAZfk9SMiohJRLXVyBDnOUESW71BkoeUI4MsM5nMWKVS+QFSDfltYZykFFFcQDUdRAL2RSWRXbd6Iol0r9dL77xRbH9MXaO5bUSseXAHL+hI/YhLOBq7Ctv5649rq5pKpbxra2ufQX+KHEM6N9ocG43GDst4WkciTBtRNM7lchtKpdIjnGWYjkhcE3U6axQzijfFCxFXdVsHZIjLchfiGulwSK16Gc9L9MMvwmigI/djIzGoO03AMOoej2c77sZXay4J24AIdh2Wc5Z1GrWdlZjKBPbUKo8JxubeYVMHFBNzqj0Ly/AiE7Djrs6YKtFizxlDxntYV6VbBXiOjCZZ/xeJ78olwW5R0CXVtqSSVY8JvSCq1Sp9FfeRGcr5Aa/gKciWjjZ0wGw2u6lcLtOX9KAV6BuCzCDYe10gxoYKiAa5CgfzViDq3kNoku6fCjvXyYED4nfobLPZfGYFW0ag4zrHdlivLtVyEOw0L+Ci32b9v5UDlxS/nrvQKGfQIKs+n2/B7/c3BsnO9h7qnCDYedy3BVpDUKNYLN6BOq6ztcMGOkO0/BNkNo+HfjwKCHrUzrEd/hckeiKW4lwEkAAAAABJRU5ErkJggg==", null, "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAFoTx1HAAAABGdBTUEAALGPC/xhBQAAADhlWElmTU0AKgAAAAgAAYdpAAQAAAABAAAAGgAAAAAAAqACAAQAAAABAAAADqADAAQAAAABAAAADgAAAACeOBvAAAABnklEQVQoFV1SzeuBQRB+3tdHys3Fx9HN6+Dk7D91IHFR8pG3XJSDUg4OohCJkET5JtbO/Np9f0ztzuwzs8/MzqwhpECK+/1+Y7/fw9BIoVBAIBD4Q16vF1wuF4XCpI0AJfoOAeZ2u2VHsViE2Wq1+KCJ6GTbNkB5SHK5nJjP50JGiul0yhg7J5MJH9RWq9XYdBMFlVsulxGPxzEej0FJH4+HUz4F/QoXvtvt0Gw2sVgskMlknBgiz2azKh3r4XDImm96vV4nWlqXy4XPZqPRQCQSwWq1YoBePpvNuEh3KpVCPp/H8XjkRV2kqk1TkhJ5vV7nHLTd73dtf3WVeM/nM7rdLjabDbc/GAwikUjwkDiv2hSFbJIolUqi0+koSOt+v8+tv16vGuNXEsloNOJpJ5NJxam1ZVkIh8Po9Xoa44v0I+TMeBTL5VI7lXE4HCAHDRqA+j1Gu90Wg8EAHo8HoVAIPp+Ps/v9fhiGgdPphGg0itvthvV6zS2NxWLO96GOpdNpUalUxPP51G8hu1qtsk9e1vhXV///alWm0r++D3qhfQw6YcpgAAAAAElFTkSuQmCC", null, "https://static.askgo.cn/prod/client/img/call.3529e11.png", null ]

[ "Full-text links:\n\nhep-th\n\n# Title: CHY-Graphs on a Torus\n\nAbstract: Recently, we proposed a new approach using a punctured Elliptic curve in the CHY framework in order to compute one-loop scattering amplitudes. In this note, we further develop this approach by introducing a set of connectors, which become the main ingredient to build integrands on $\\mathfrak{M}_{1,n}$, the moduli space of n-punctured Elliptic curves. As a particular application, we study the $\\Phi^3$ bi-adjoint scalar theory. We propose a set of rules to construct integrands on $\\mathfrak{M}_{1,n}$ from $\\Phi^ 3$ integrands on $\\mathfrak{M}_{0,n}$, the moduli space of n-punctured spheres. We illustrate these rules by computing a variety of $\\Phi^3$ one-loop Feynman diagrams. Conversely, we also provide another set of rules to compute the corresponding CHY-integrand on $\\mathfrak{M}_{1,n}$ by starting instead from a given $\\Phi^ 3$ one-loop Feynman diagram. In addition, our results can easily be extended to higher loops.\n Comments: 34 pages, 32 figures Subjects: High Energy Physics - Theory (hep-th); Mathematical Physics (math-ph) DOI: 10.1007/JHEP10(2016)116 Cite as: arXiv:1607.01871 [hep-th] (or arXiv:1607.01871v1 [hep-th] for this version)\n\n## Submission history\n\nFrom: Humberto Gomez [view email]\n[v1] Thu, 7 Jul 2016 04:24:02 GMT (933kb,D)\n\nLink back to: arXiv, form interface, contact." ]

[ null ]