Our developers just showed me this. Yes, that’s Pando supporting multi-byte characters!

Share This

Peer-to-peer (P2P) technology has become one of the hottest topics lately in the online video industry. Controversy now surrounds the role P2P will play especially in high-quality video delivery on the Net. Does P2P have a legitimate shot at becoming a mass-market distribution model or will networks block the traffic before it has the chance? If P2P really is cheaper and better, then why haven’t content providers adopted it en masse? What’s missing from P2P business models? Can P2P truly support live delivery, Flash-based videos, VOD security, broadcast audience scalability? These and many other questions will be addressed in this interactive session at Streaming Media East in NYC on Tuesday at 1:45. The panel includes Robert Levitan, our CEO, as well as Patty Perkins, VP, Special Projects Manager, Wachovia Video Network, Wachovia Bank, Doug Pasko, PMTS, Network and Technology Group, Verizon and Barry Tishgart, VP, Internet Services, Comcast.

Share This

Jay Rand is presenting “Part 2″ of his presentation on raising money for technology companies, walking us through a typical term sheet and addressing more advanced topics.

Mr. Rand is the Co-Chair of Manatt’s Venture Capital and Technology Practice Group. His corporate practice focuses on the representation of investment funds, including venture capital and private equity funds, and the companies backed by these funds. He represents clients in industries ranging from information technology, new and traditional media, software, health services and life sciences to consumer goods and services. His expertise includes equity and debt financings, mergers and acquisitions, licensing transactions, joint ventures, strategic alliances and other corporate and securities matters. Mr. Rand also counsels investment funds regarding formation, capital raising and governance matters.

Location: Manatt @ 7 Times Square (entrance on Broadway) 23rd Floor, New York , NY 10036.

Share This

This Friday the Pandos and blip.tv crew met at High Velocity for a friendly death match of Paintball. Photographers Hiro and Angus documented the event.

I learned a few things. Cover is important. Keep moving, or you’ll get pinned down. Running out of ammunition in the middle of a gunfight is a bad idea. Having Israelis on your team is a good idea. And it feels really, really good to soak in a hot tub after spending a day running around and crawling in the dirt while covered in paint. I look forward to doing it all again.

Yaron, who inspired this event, wrote a nice post.

Share This

A Pando fan writes “This is just funny! My dog’s name is PANDO!”.

She sent us a fantastic photograph of her handsome dog. Yes, his name really is Pando, and he’s very stylish!

Share This

Hi, my name is James Royalty and I’m a Pando blog n00b.  We recently opened our blog to contributions from all staff members at Pando and personally I’m excited.  I’m looking forward to the talented people I have the opportunity to work with daily sharing their thoughts and recent projects here.  Look for more soon.

In addition to being a P.blog n00b, I’m also a server-side engineer here at Pando.  The server team handles all the stuff you don’t see when using Pando:  trackers, storage proxies, web services etc.  So, I’m happy to have the chance to write about a cool feature we’ve been working on — P4P.  P4P received quite a bit of press coverage recently (as Laird mentioned in his last post) and we thought this would be a great time to give you an idea how it works.  After all, P4P comes from an open working group.

In terms of peer-to-peer infrastructure, P4P integration is done at the tracker-level.  This post is fairly technical and geared toward developers wondering how they might add P4P capabilities to their tracker.  P4P is, at the end of the day, a fairly simple concept and integrating it is straightforward, but there is a lot to explain.  I’ve decided to break up the necessary information into two posts.

1. API and P4P data.  How to obtain P4P data (at runtime) and what the data look like.  We’ll cover this here.
2. Using P4P data.  How to apply P4P during peer announcement.

That’s the current plan at least.  I’ll watch the comments to this post, so if you’d like for me to elaborate on something or go in a different direction, please speak up.  :)

Okay, enough preamble.  Let’s get to it!

Basics

Openp4p.net has some excellent background information under the Q&A and Field Tests sections.  In particular, the Field Tests section has a nice picture of the an integrated P4P system under the “Information Flow” heading.  If you are unfamiliar with P4P, go check those out and come back.

Hi, welcome back.  All caught up?  Good.  Let’s move on to some terminology.

• iTracker.  A special tracker with special knowledge of one or more ISP’s network topology.  The iTracker provides this data to your tracker and makes peer recommendations based on the state of your swarm.
• AS ID.  An autonomous system identifier.  For simplicity’s sake think of an ASID as the name of a particular ISP.
• PID.  A point of presence (POP) identifier.  Consider this an aggregation of all networks within a certain “region”.
• Network location.  An (AS ID, PID) pair.

To summarize the basics:  the iTracker provides data to determine the network location of peers in a swarm.  Your tracker communicates the state of a (P4P-enabled) swarm to the iTracker and gets a set of recommended peers — with respect to ISP — in return.  So, you need to communicate with the iTracker… here’s how.

iTracker API and Data

Implementors of P4P interact with the iTracker using a very simple SOAP-based API.  We have not made a WSDL publicly available as some semantics are likely to change.  So, instead of talking in specifics here, I’ll discuss interaction with the iTracker in terms of pseudo code.  Keep these structures in mind as I’ll refer to them later.

Method:

GetASIDsResponse GetASIDs()

Input:

None

Output:

GetASIDsResponse {

ARRAY asids

}

Integration with the iTracker starts here.  Normally, on (your) tracker startup, you’ll invoke this method to discover the AS IDs the iTracker has data for.  Even though AS IDs are often human-readable strings you should treat them as opaque values; you’ll use them as input to the next method.

Method:

GetPrefixResponse GetPrefix( asid )

Input:

An AS ID returned by GetASIDs().

Output:

GetPrefixResponse GetPrefix( ASID )
GetPrefixResponse {

ARRAY PidPrefixes {
pid
ARRAY networkPrefix
}

}

This method returns a description of the given AS in terms of network structure.  The iTracker’s data model is such that ASes contain one or more PIDs and PIDs contain one or more network addresses.  So, let’s consider an AS called “sampleAS” with two PIDs, “samplePID1″ and “samplePID2″ where each PID contains two /24 networks.  Here’s an outline of the data returned by GetPrefix().

• AS ID = sampleAS
• PID = samplePID1
• 192.168.22.1/24
• 192.168.22.2/24
• PID = samplePID2
• 192.168.23.1/24
• 192.168.23.2/24

You’ll need to keep this data easily accessible within your tracker (i.e., in memory if possible) because as peers in a P4P-enabled swarm announce you’ll use this information to determine their P4P network location.  How?  By finding the longest prefix match using a peer’s IP address.  (Note that network addresses are returned in CIDR block form.)  This lookup should be quick so choosing an efficient data structure is important.  Good choices include Tries or Patricia Tries.  One structure I came across while adding P4P to Pando’s tracker is a SIGCOMM’97 paper titled Scalable High Speed IP Routing Lookups.  It describes a pretty neat way to do binary search over a set of hash tables storing prefixes.  It might be a little exotic for some implementations but is worth keeping in mind.

Getting back to the method at hand, you should call GetPrefix() for each AS ID (as returned by GetASIDs()) you are interested in.  Store the network addresses in a data structure allowing longest matching prefix lookup.  In this structure, network addresses should be keys and values should be (AS ID, PID) pairs (the network location).  Here’s an example.

// Assume allPrefixes is your prefix lookup structure
forall as in GetASIDs() {

forall pref in GetPrefix( as ) {

forall netprefix in pref.networkPrefix {
allPrefixes.add( as, pref.pid, netprefix )
}

}

}

Later, when a peer announces in your P4P-enabled swarm you’ll assign it a network location, using the allPrefixes structure as follows.

if ( peer.networkLocation is empty OR peer.ipAddress changed ) {

peer.networkLocation = allPrefixes.lookup( peer.ipAddress )

}

The “if” clause is to there to save some work; you only need to make this assignment once.  However, if the same peer announces with a different IP address and port then you’ll need to update that peer’s network location.  (Assuming you use something other than IP:port to uniquely identify a peer within a swarm.)

The data returned by calls to GetASIDs() and GetPrefix() changes very infrequently, but they do change.  Pando’s tracker calls GetPrefix() every 24 hours and GetASIDs() only on startup.

Method:

GetPeeringWeightResponse GetPeeringWeight( GetPeeringWeightRequest )

Input:

GetPeeringWeightRequest {

swarmId
ARRAY SwarmState {

asid
pid
numLeeches
numSeeds
uploadCapacity
downloadCapacity
}

}

Output:

GetPeeringWeightResponse {

swarmId
ARRAY PeeringWeight {

sourceASID
sourcePID
destinationASID
destinationPID
weight

}

}

The methods we’ve discussed up to this point involve you fetching relatively static data from the iTracker.  Using GetPeeringWeight(), you get communicate what’s going on inside your tracker.  This method is central to P4P and sets it apart from other network location-based peer selection methods:  the iTracker makes dynamic peer recommendations based on the state of your swarm (as expressed by GetPeeringWeightRequest) and an ISP’s preferences regarding traffic flow.  Exactly how the iTracker makes these recommendations is beyond the scope of this post so let’s focus on communicating the state of your swarm.

Information in GetPeeringWeightRequest is an aggregation along (AS ID, PID) pair lines.  That is, for each (AS ID, PID) in a given given swarm, sum up the number of leeches and seeds along with the estimated total upload and download capacity (more on that in a second).  For example, say we have a swarm XYZZY (this is an arbitrary unique identifier; a simple choice is to use the BitTorrent info hash) with peers from one AS ID (”sampleAS”) and two PIDs (”samplePID1″ and “samplePID2″).  Here’s a outline of the data sent to GetPeeringWeight().

• swarmId = XYZZY
• asid=sampleAS, pid=samplePID1
• numLeeches = 2000
• numSeeds =  500
• uploadCapacity = 100.0
• downloadCapacity = 256.0
• asid=sampleAS, pid=samplePID2
• numLeeches = 200
• numSeeds =  1000
• uploadCapacity = 0.0
• downloadCapacity = 0.0

As I mentioned, the number of leeches and seeds is summed within a particular (AS ID, PID).  Peers that have no network information are suppressed from the above.  So, in actuality, the size of this swarm may be larger, but in the P4P sense, there are 2200 leeches and 1500 seeds (across all AS IDs).

Back to upload/download capacity:  If you are unable to obtain this information (e.g., your peers don’t announce with a number of bytes transferred ) just set both to 0.0.  If your peers do announce with number of bytes transferred you can compute these capacities as a function of a peer’s announce interval.

Now you are ready to make calls to GetPeeringWeight().  You don’t need to fetch the weights on every announce; computing swarm state and interpreting GetPeeringWeightResponse can take some time, especially for large swarms.  So how often should you call GetPeeringWeight()?  A simple approach is to invoke on fixed intervals; every five minutes, for example.  While simple, calling only on fixed intervals could mean that new peers don’t benefit of P4P recommendations on their first couple of announces (assuming you have no existing peers in their (AS ID, PID)).

A more sophisticated approach is to determine the frequency of calls to GetPeeringWeight() as a function of the arrival rate of new peers.  If new peers are arriving at a high rate, invoke GetPeeringWeight() every few seconds.  As the arrival rate drops and your swarm stabilizes, make calls less frequently (up to a maximum interval of 5 minutes, say).

Wrap up

As this post is already pretty long I’ll save the details of GetPeeringWeightResponse for the next post.  In the meantime, please leave questions and suggestions for the next post in the comments.  Cheers!  –James

Share This

Pando has been working on a new technology called P4P, which I’ve blogged about before. Typical P2P networks download data from random locations, but working with ISP’s lets you figure out who is near you in the network, so that you can download from nearby computers. Simulations run by Yale University showed that this should result in faster downloads, so we proceeded to implement P4P in Pando’s network to see how it works in the real world. For the past few weeks we have been running a field test, working with Verizon, Telefonica, and Yale University to optimize the delivery of the latest episode of the Pandomonium Minute. We now have the results of the test, and they are a stunning confirmation of the value of more than 50 ISP’s, P2P companies and researchers working together.

• In standard P2P, 6% of the data downloaded came from people near you, and the rest from all over the planet (i.e. slowly and at great cost to the ISP’s). With P4P, a whopping 58% of that data downloaded came from people near you.
• For FTTH (FiOS) users, speeds increased on average by over 200%. Some users saw as much as a 665% speedup!
• The ISP’s saw data delivery distance, and thus cost, drop from an average of 5.5 long-distance links to 0.89. And the volume of data downloaded from other ISP’s dropped by more than 50%!

This is a historic day that changes the relationship between P2P networks and ISP’s. As Verizon put it “It’s about efficiency for content holders. If we share our maps, the Pando people can find the best path.” And then we all win!

There have been a few thousand articles on P4P (Google is your friend). Check out AP, Slashdot, Ars Technica, The LA Times, CNNMoney, Fox and BetaNews.

There’s an overview of P4P and the P4P Working Group. If you’re interested in learning more, email me.

Share This

My friends I have a special personal announcement to make today. Four years ago, on this day, I started working on an idea to change the way people and companies move and monetize high quality video online. That idea, which became a reality thanks to my co-founders Laird and Robert, our superstar team and some brave investors, blossomed into my greatest professional achievement to-date; Pando Networks. Today, with over 17 million users worldwide and media giants such as NBC as customers, Pando is a leader in the exciting Peer-Assisted Content Delivery space. We’re helping to standardize P2P so that it works for everyone and more importantly to ensure that our aging Internet doesn’t buckle under the tsunami of high quality video coming online. We’re also helping family and friends stay connected by sharing their life moments and creativity across continents with full-screen, full-length personal videos and media. Your enthusiastic feedback and support over the years has been my greatest daily reward. Thank you.

Pando has always been more than a job for me. It’s my baby and my passion. I’ve given it the best four years of my life and it has given me more than I could have imagined both personally and professionally. It now gives me great pride to realize that we’ve brought the company to a point where I can move on to my next crazy idea with the confidence that Pando is not only at the best place that its ever been, but that its being run by dear friends that are uniquely capable of taking it to the next level. Exciting things are ahead this year for Pando.

It’s with a mixture of sentimental reflection, deep gratitude and building forward excitement that today I announce my last full-time day at Pando. I’m jumping back in the water again and starting to work on my next company. I am transitioning from my day-to-day role as Pando’s CMO but will remain an active advisor, joining our distinguished advisory board. I will continue to help the company realize our ambitious mission of creating a new Internet infrastructure standard for efficient, secure and commercially viable rich media delivery. We’re at the right spot, at the right time, with the right people to do it.

So what’s next for me? First of all, a one-week vacation! I’ll be blogging about my new company here in a few months but for now I’m going into stealth mode. I’ll still be organizing NY Video 2.0 and NY Israel Tech; two startup peer groups whose 2,000 creative thinkers have inspired me to get back out there again.

Pando Blog
My brilliant uber-geek co-founder, Laird Popkin will be taking over the Pando Blog along with a host of shiny Pandos that will be contributing to it on a regular basis. Should be a lot of fun so stick around. In the meantime, say hi to the team (at lunch yesterday):

Stay in touch! (No really)
I’m always available at yaron@pando.com or my personal email address and you can find me online at LinkedIn, Facebook and Flickr.

Onward and upward Pandos!

Yaron Samid
Co-founder, Pando Networks

Share This

There are watershed moments in every startup’s life that define its history. Same goes for entire industries. In rare cases, those moments are one in the same. Today we officially announced that NBC has embraced p2p for the direct-to-viewer downloads of their primetime TV programming, becoming the first US TV network to do so. The company and technology they selected, after “a comprehensive search and intensive due diligence of available solutions” according to Steve Andrade, Senior Vice President, Digital Development and General Manager NBC.com, is Pando Networks. We could not be more thrilled and honored to take part in this historic step forward for TV.

With the new NBC Direct service, viewers will be able to download and subscribe to their favorite shows such as The Office, Heroes, Conan Obrien, etc. and have each new episode delivered automatically to their desktop in full-screen, HD quality for on and offline viewing on their laptop, PC or TV. This is TV 2.0 folks. You’re in charge.

Pando’s Media Booster engine is being integrated into the NBC Direct client to optimize the delivery of the TV programming. Our hybrid p2p-cdn delivery economics make it not only possible, but profitable to distribute huge HD video files monetized with only a few ads. That means free, primetime HD TV for viewers with limited advertising — a huge win for viewers and content providers alike.

We tip our hats to our friends at NBC for continuing their impressive tradition of new media innovation and leadership. Onward and upward. Read on.

Share This

Sounds like a funky Asian-Australian primate fusion, but its our latest exciting partnership — a collaboration with Roo Group, a leading VMS provider. Integrating our peer-assisted content delivery service into Roo’s video player and management system will enable their current and future customers to enjoy radical cost savings while unleashing their highest quality video to unlimited audiences. Viewers will be given the option to activate the Pando Media Booster directly from Roo Video Players in order to enjoy accelerated, HD and higher quality streams. This is actually a three-way alliance that includes Abacast, a great live p2p streaming provider. We’ve long held the belief that seamlessly integrated, end-to-end solutions are the way to go for wide-scale video deployments and this partnership brings the respective strengths of Roo, Abacast and Pando together for the betterment of content providers. Good stuff.

Share This